Unit04： 集合框架 、 集合操作 —— 线性表
操作集合元素相关方法
package day04; import java.util.ArrayList;
import java.util.Collection; import day02.Point; /**
* 操作集合元素相关方法
* @author adminitartor
*
*/
public class Collection_Remove {
public static void main(String[] args) {
Collection c = new ArrayList();
c.add(new Point(1,2));
c.add(new Point(3,4));
c.add(new Point(5,6));
c.add(new Point(1,2)); System.out.println(c); Point p = new Point(1,2);
/*
* boolean remove(E e)
* 从集合中删除给定元素
* 将给定元素与集合现有元素顺序进行equals
* 比较，并删除第一个与之比较为true的元素
* 若成功删除元素则返回true
*/
c.remove(p);
System.out.println(c);
}
}
Collection_Remove.java
集合操作
package day04; import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet; /**
* 集合操作
* @author adminitartor
*
*/
public class Collection_Methods {
public static void main(String[] args) {
Collection c1 = new ArrayList();
c1.add("java");
c1.add("c++");
c1.add("c#"); Collection c2 = new HashSet();
c2.add("android");
c2.add("ios");
c2.add("java");
/*
* boolean addAll(Collection c)
* 将给定集合中的所有元素添加到当前集合
* 中，方法调用完毕后当前集合元素发生了
* 变化，则返回true
*/
c1.addAll(c2);
System.out.println(c1); Collection c3 = new ArrayList();
c3.add("android");
c3.add("c#");
// c3.add("php");
/*
* boolean containsAll(Collection c)
* 判断当前集合是否包含给定集合中的所有
* 元素
*/
boolean contains = c1.containsAll(c3);
System.out.println("全包含:"+contains); /*
* 删除当前集合中与给定集合共有元素
*/
c1.removeAll(c3);
System.out.println(c1);
}
}
Collection_Methods.java
遍历集合
package day04; import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator; /**
* 遍历集合
* 集合提供了通用的遍历元素方式:迭代器模式。
* 迭代器java.util.Iterator是一个接口。
* 不同的集合实现类都提供了一个可以遍历自身元素的
* 迭代器实现类，我们无需记住每个迭代器实现类的名字
* 只要当Iterator看待可以操作并遍历集合元素即可。
*
* 迭代器遍历集合元素遵循:
* 问，取，删 的步骤
* 其中删除元素操作不是必要操作。
* @author adminitartor
*
*/
public class Collection_Iterator {
public static void main(String[] args) {
Collection c = new ArrayList();
c.add("one");
c.add("#");
c.add("two");
c.add("#");
c.add("three");
c.add("#");
c.add("four");
c.add("#");
c.add("five");
System.out.println(c); //获取用于遍历该集合元素的迭代器
Iterator it = c.iterator();
/*
* boolean hasNext()
* 判断集合是否还有元素可以取出
*/
while(it.hasNext()){
/*
* E next()
* 取出下一个元素
*/
String str = (String)it.next();
if("#".equals(str)){
/*
* 在使用迭代器遍历集合元素时，
* 不要通过集合的方法修改元素数量，
* 否则会抛出异常
*/
// c.remove(str);
/*
* 迭代器的remove方法可以将刚
* 通过next方法取出的元素从集合
* 中删除。
*/
it.remove();
}
System.out.println(str);
} System.out.println(c);
}
}
Collection_Iterator.java
增强for循环
package day04;
/**
* 增强for循环
* 也称为新循环，for each
* JDK1.5之后推出的新特性
* 新循环不能替代传统循环的工作，新循环使用来遍历
* 集合或数组的
* @author adminitartor
*
*/
public class NewFor_Array {
public static void main(String[] args) {
String[] array = {"one","two","three","four","five"}; for(int i=0;i<array.length;i++){
String str = array[i];
System.out.println(str);
} for(String str : array){
System.out.println(str);
}
}
}
NewFor_Array.java
使用新循环遍历集合
package day04; import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator; /**
* 使用新循环遍历集合
* @author adminitartor
*
*/
public class NewFor_Collection {
public static void main(String[] args) {
Collection c = new ArrayList();
c.add("one");
c.add("two");
c.add("three");
c.add("four");
c.add("five");
/*
* 新循环并非新的语法，JVM并不认可新循环
* 而是编译器认可。
* 编译器在编译源程序时，会将新循环遍历
* 集合改为使用迭代器遍历。
* 为此，新循环在遍历集合时，不能通过集合
* 的方法修改元素数量。
*/
for(Object o : c){
// Iterator it = c.iterator();
// while(it.hasNext()){
// Object o = it.next();
String str = (String)o;
System.out.println(str);
}
}
}
NewFor_Collection.java
测试泛型的使用
package day04;
/**
* 测试泛型的使用
* @author adminitartor
*
*/
public class TestPoint {
public static void main(String[] args) {
Point<Integer> p1
= new Point<Integer>(1,2);
p1.setX(2);
int x1 = p1.getX();
System.out.println("x1:"+x1); Point<Double> p2
= new Point<Double>(1.1,2.2);
p2.setX(2.2);
double x2 = p2.getX();
System.out.println("x2:"+x2); Point<String> p3
= new Point<String>("一","二");
p3.setX("二");
String x3 = p3.getX();
System.out.println("x3:"+x3); }
}
TestPoint.java
泛型 JDK1.5之后推出的新特性
package day04;
/**
* 泛型 JDK1.5之后推出的新特性
* @author adminitartor
*
*/
public class Point<T> {
private T x;
private T y;
public Point(T x, T y) {
super();
this.x = x;
this.y = y;
}
public T getX() {
return x;
}
public void setX(T x) {
this.x = x;
}
public T getY() {
return y;
}
public void setY(T y) {
this.y = y;
} @Override
public String toString() {
return "("+x+","+y+")";
}
}
Point.java
泛型并非虚拟机认可，而是编译器认可,泛型的原型就是Object。
package day04;
/**
* 泛型并非虚拟机认可，而是编译器认可
* 泛型的原型就是Object。所以，Point中所有<T>的地方
* 会被编译器改为Object
* 编译器在检查使用泛型的地方时做如下操作:
* 在给一个泛型赋值时，检查实际的值是否满足类型要求
* 获取一个泛型的值时，会自动添加类型转换代码
* @author adminitartor
*
*/
public class TestPoint2 {
public static void main(String[] args) {
/*
* Point里面的x,y实际是Object
* 由于有泛型，编译器会检查构造方法中
* 实际传入的值是否符合Integer的类型，
* 不符合编译不通过
*/
Point<Integer> p1
= new Point<Integer>(1,2); p1.setX(2);
/*
* 编译后的class文件中编译器会补上向下
* 造型的代码:
* int x1 = (Integer)p1.getX();
*/
int x1 = p1.getX();
System.out.println("x1:"+x1);
/*
* 不指定泛型的实际类型那么则使用默认
* 的Object
*/
Point p2 = p1;
p2.setX("二");
System.out.println("x2:"+p2.getX());//"二" x1 = p1.getX();//ClassCastException
System.out.println(x1);//?
}
}
TestPoint2.java
泛型在集合中的应用
package day04; import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator; /**
* 泛型在集合中的应用
* 集合在泛型中是用来规定集合中的元素类型
* @author adminitartor
*
*/
public class Collection_Type {
public static void main(String[] args) {
Collection<String> c
= new ArrayList<String>();
c.add("one");
c.add("two");
c.add("three");
c.add("four"); for(String str : c){
System.out.println(str);
}
/*
* 迭代器也支持泛型，而泛型的实际类型与
* 其遍历的集合的泛型类型一致即可
*/
Iterator<String> it = c.iterator();
while(it.hasNext()){
String str = it.next();
System.out.println(str);
}
}
}
Collection_Type.java
List集合
package day04; import java.util.ArrayList;
import java.util.List; /**
* List集合
* List是可重复集，并且有序
* 特点是可以像数组一样，通过下标操作元素
* 并且也提供了一系列根据下标操作元素的方法
* @author adminitartor
*
*/
public class List_Get_Set {
public static void main(String[] args) {
List<String> list
= new ArrayList<String>(); list.add("one");
list.add("two");
list.add("three");
list.add("four");
System.out.println(list); /*
* E get(int index)
* 获取给定下标处的元素
*/
//获取第二个元素
String str = list.get(1);
System.out.println(str);
//可以使用传统for循环遍历List集合
for(int i=0;i<list.size();i++){
str = list.get(i);
System.out.println(str);
} /*
* E set(int index,E e)
* 将给定元素设置到指定位置处，返回值
* 为原位置对应的元素。
*/
//[one,two,three,four,five]
String old = list.set(1, "2");
System.out.println(list);
System.out.println(old);
}
}
List_Get_Set.java
List提供了一对重载的add,remove方法
package day04; import java.util.ArrayList;
import java.util.List; /**
* List提供了一对重载的add,remove方法
* @author adminitartor
*
*/
public class List_Add_Remove {
public static void main(String[] args) {
List<String> list
= new ArrayList<String>();
list.add("one");
list.add("two");
list.add("three");
list.add("four");
System.out.println(list);
/*
* void add(int index,E e)
* 向集合指定位置插入给定元素
*/
//[one,2,two,three,four]
list.add(1, "2");
System.out.println(list); /*
* E remove(int index)
* 删除给定位置上的元素并将其返回
*/
//[one,2,three,four]
String old = list.remove(2);
System.out.println(list);
System.out.println(old);
}
}
List_Add_Remove.java
截取List集合的子集
package day04; import java.util.ArrayList;
import java.util.List; /**
* 截取List集合的子集
* @author adminitartor
*
*/
public class List_Sublist {
public static void main(String[] args) {
List<Integer> list
= new ArrayList<Integer>(); for(int i=0;i<10;i++){
list.add(i);
}
System.out.println(list);
//取3-7
List<Integer> subList
= list.subList(3, 8);
System.out.println(subList); //将子集元素扩大10倍
for(int i=0;i<subList.size();i++){
subList.set(i, subList.get(i) * 10);
} System.out.println(subList);
/*
* 对子集元素的操作就是对原集合相应内容
* 的操作
*/
System.out.println(list); /*
* 删除3-7
*/
list.subList(3, 8).clear();
System.out.println(list);
}
}
List_Sublist.java
集合转换为数组
package day04; import java.util.ArrayList;
import java.util.Collection; /**
* 集合转换为数组
* Collection提供了方法:toArray
* @author adminitartor
*
*/
public class CollectionToArray {
public static void main(String[] args) {
Collection<String> c
= new ArrayList<String>();
c.add("one");
c.add("two");
c.add("three");
c.add("four");
System.out.println(c);
//不常用
// Object[] array = c.toArray(); String[] array
= c.toArray(new String[c.size()]);
System.out.println("len:"+array.length);
for(String str : array){
System.out.println(str);
}
}
}
CollectionToArray.java
数组转换为集合
package day04; import java.util.ArrayList;
import java.util.Arrays;
import java.util.List; /**
* 数组转换为集合
* 使用数组的工具类Arrays的静态方法asList
* 需要注意，只能将数组转换为List集合。
* @author adminitartor
*
*/
public class ArrayToList {
public static void main(String[] args) {
String[] array = {"one","two","three","four"}; List<String> list = Arrays.asList(array);
System.out.println(list.size());
System.out.println(list);
/*
* 修改集合元素就是修改原数组对应元素
*/
list.set(1, "2");
System.out.println(list); for(String str : array){
System.out.println(str);
}
/*
* 添加新元素会导致数组扩容，不允许这样
* 做，因为这样不能表示原数组了。
*/
// list.add("five");//会抛出异常
// System.out.println(list);
/*
* 若想添加新元素，可以自行实例化一个集合
*/
List<String> list1
= new ArrayList<String>(list);
// list1.addAll(list);
list1.add("five");
System.out.println(list1);
}
}
ArrayToList.java
使用集合的工具类Collections的静态方法sort,可以对List集合进行自然排序(从小到大)
package day04; import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random; /**
* 使用集合的工具类Collections的静态方法sort
* 可以对List集合进行自然排序(从小到大)
* @author adminitartor
*
*/
public class SortList {
public static void main(String[] args) {
List<Integer> list
= new ArrayList<Integer>(); Random random = new Random();
for(int i=0;i<10;i++){
list.add(random.nextInt(100));
}
System.out.println(list);
Collections.sort(list);
System.out.println(list);
}
}
SortList.java