Java.集合续

addAll(Collection c)

boolean addAll(Collection c) 将给定集合中的所有元素添加到当前集合中
eg：将c2集合中的元素增加到c1集合中

		Collection c1 = new ArrayList() ;
		c1.add("java") ;
		c1.add("c++") ;
		c1.add("c#") ;
		System.out.println("c1:" + c1) ;
		Collection c2 = new HashSet() ;
		c2.add("android") ;
		c2.add("iss") ;
		c2.add("java");
		System.out.println("c2:" + c2) ;
		c1.addAll(c2);    
		System.out.println("c1:" + c1) ;

输出结果：
c1:[java, c++, c#]
c2:[java, android, iss]
c1:[java, c++, c#, java, android, iss]

containsAll(Collection c)

boolean containsAll(Collection c) 判断当前集合是否包含给定集合中的所有元素
eg：判断c1是否包含c3所有元素

		Collection c3 = new ArrayList() ;
		c3.add("android");
		c3.add("c++") ;
		System.out.println("c3:" + c3);
		boolean contains = c1.containsAll(c3);
		System.out.println("c1包含c3所有元素：" + contains);

输出结果：
c1:[java, c++, c#]
c2:[java, android, iss]
c1:[java, c++, c#, java, android, iss]
c3:[android, c++]
c1包含c3所有元素：true

removeAll(Collection c)

removeAll(Collection c) 删除两个集合中共有的元素，给定集合(c3)中的元素不会发生变化，可以理解为删除两个集合的交集
eg:删除c1集合和c3集合共有的元素，c3集合中的元素不会发生变化

public static void main(String[] args){
		Collection c1 = new ArrayList() ;
		c1.add("java") ;
		c1.add("c++") ;
		c1.add("c#") ;
		System.out.println("c1:" + c1) ;
		Collection c2 = new HashSet() ;
		c2.add("android") ;
		c2.add("iss") ;
		c2.add("java");
		System.out.println("c2:" + c2) ;
		c1.addAll(c2);    
		System.out.println("c1:" + c1) ;
		Collection c3 = new ArrayList() ;
		c3.add("android");
		c3.add("c++") ;
		System.out.println("c3:" + c3);
		c1.removeAll(c3);
		System.out.println("c1:" + c1);
		}

输出结果：
c1:[java, c++, c#]
c2:[java, android, iss]
c1:[java, c++, c#, java, android, iss]
c3:[android, c++]
c1:[java, c#, java, iss]

迭代器模式

概述

Collection提供了一个统一的遍历集合的方式：迭代器模式

• Iterator iterator()
• 该方法是Collection上定义的方法，所有集合都实现了该方法
• 作用是返回一个可以用于遍历当前集合的迭代器实现类
• java.util.Iterator接口，是迭代器接口，定义了遍历集合的相关操作方法，不同的集合都实现了一个遍历自身元素的迭代器实现类，但是我们无需记住实现类的名字，只要将它们视为Iterator并调用相关方法进行遍历集合即可
• 迭代器遍历集合遵循的步骤为：问、取、删，其中删除元素不是遍历集合时的必要条件

public class IteratorDemo {
	public static void main(String[] args) {
		Collection c = new ArrayList() ;
		c.add("鸭蛋") ;
		c.add("e");
		c.add("a");
		/*
		 * i.hasNext() 检查游标位置是否下一个元素，如果有元素返回true
		 * i.next() 移动到游标下一个，返回这个元素
		 */
		Iterator i = c.iterator();    //while 和hasNext() next() 是固定搭配
		while(i.hasNext()) {
			Object obj = i.next();
			System.out.println(obj);
		}
	}
}

输出结果：
鸭蛋
e
a

迭代器删除

概述

传统集合迭代期间删除数据(增加数据)会有可能出现异常，迭代器提供安全删除方法，可以在迭代期间安全删除当前集合中元素
Iterator.remove()删除当前游标正在操作的

public class IteratorDemo3 {
	public static void main(String[] args) {
		Collection<Integer> c = new ArrayList<>();
		c.add(10);
		c.add(20);
		c.add(30);
		c.add(40);
		c.add(50);
		c.add(60);
		Iterator<Integer> i = c.iterator();
		while(i.hasNext()) {
			Integer n = i.next();
			//如果找到==30就从集合中删除n
			if(n.equals(30)) {
				//安全删除方法会从原集合删除元素，相当于c.remove(n),并且不会出先异常
				//安全删除方法
				i.remove();
				//c.remove(n);  //不安全的删除，出现异常
			}
			System.out.println(n);
		}
		System.out.println(c);
		Collection<Double> c1 = new ArrayList<>();
		c1.add(3.36);
		c1.add(63.36);
		c1.add(63.2563);
		Iterator<Double> u = c1.iterator();
		while(u.hasNext()) {
			Double m = u.next();
			if(m.equals(3.36)) {
				u.remove();
			}
			System.out.println(m);
		}
		System.out.println(c1);
		/*
		 * 增强for循环，没有迭代期间删除方法，适合循环期间不删除集合元素的场景。如果在循环遍历期间删除元素，请使用迭代器循环，
		 * 利用迭代器的方法删除元素
		 */
	}
}

输出结果
20
30
40
50
60
[10, 20, 40, 50, 60]
3.36
63.36
63.2563
[63.36, 63.2563]

泛型

概述

1. 可以约束集合中元素的类型
2. 可以自动完成强制类型转换
3. 集合<类型> Collection表示集合中只能存储String类型数据，其他类型不存储
4. 创建集合时候
   (1)java 7 以前 new ArrayList()
   (2)java 7 以后 new ArrayList<>()

public class IteratorDemo1 {
	public static void main(String[] args) {
		Collection<Integer> c = new ArrayList<>() ;
		c.add(1);  //基本类型参数自动包装为Integer
		c.add(2);
		c.add(3);
		c.add(4);
		//c.add("shhs");泛型检查错误，好处是可以检查类型
		Iterator<Integer> i = c.iterator();
		while(i.hasNext()) {
			//有了泛型，可以自动完成强制类型转换
			Integer a = i.next();
			System.out.println(a);
		}
		/*
		 * 不能将基本类型存储到集合中，需要转换为包装类型再存储到集合中，泛型也是，使用泛型时也必须声明为包装类型
		 */
		Collection<Double> r = new ArrayList<>();
		r.add(3.35);
		r.add(6.36);
		r.add(null);
		r.add(9.36);
		r.add(9.365);
		Iterator<Double> q = r.iterator();
		for(Iterator<Double> q1 = r.iterator();q1.hasNext();){
			/*
			 * 自动拆包装自动调用i.intValue()
			 * 调用时候因为变量i的值是null的时候，会引发空指针异常
			 */
			Double s = q1.next();
			if(s == null) continue ;
			System.out.println(s);
		}
		/*
		 * 解决上述问题办法有两种：
		 * 1.编程的时候，要避免null出现在集合中 
		 * 2.使用Integer类型接受数据，再利用if语句处理
		 */
		/*
		 * 增强for循环也可以遍历集合
		 */
//		for(元素 : 集合) {
//			
//		}
		for(Double e : r) {
			//会将q1中的每个元素赋值到变量e
			System.out.println(e);			
		}
		/*
		 * 上述for(Double e : r)的工作原理：
		 * java编译器在编译时自动会替换为如下语句
		 * for(Iterator<Double> q1 = r.iterator();q1.hasNext();){
		 * Double s = q1.next();
		 * }
		 * 可以将增强for循环看做是一个简化版的“迭代器遍历”
		 */
	}
}

输出结果
10
20
30
40
50
60
[10, 20, 40, 50, 60]
3.36
63.36
63.2563
[63.36, 63.2563]