java中的【集合】

集合的概念

目前代码中对于多个数据处理过程中，我们采用的方式是数组方式。
数组操作存在的问题:
1. 复用度差！！！
目前对于数据操作有且只能支持一个数据类型，一旦需要操作其他类型，全部
重构，从头来过
2. 空间固定！！！
数组的空间一旦在创建过程中确定，空间无法修改。
3. 方法较少！！！
add remove modify get 。。。
自己写的！！！方法自己实现，体验不好！！！Java中对于数组操作没有提供
太多的有效方法

以上问题集合都可以解决！！！
1. 复用性，没有问题！！！
集合创建采用了泛型模式，可以用户指定任意类型操作！！！既满足普适性，又满足数据类型一致化要求
2. 空间在合理范围以内自行扩展，不需要考虑容量问题
3. 方法很多！！！操作性很好 ！！

Collection接口下常用方法

增：
boolean add(E e)
添加当前集合约束的指定数据类型到当前集合中

boolean addAll(Collection<? extends E> c);
	添加另一个集合到当前集合中，要求添加集合中保存的元素必须是当前集合中保存
	元素本身或者其子类对象 【泛型的上限】
	class Dog extends Animal
	class Cat extends Animal
	class Tiger extends Animal

删：
boolean remove(Object obj);
删除集合中的指定元素，删除成功返回true,未找到指定元素，无法删除返回
false，并且在多个元素的情况下，删除找到的第一个元素。

boolean removeAll(Collection<?> c);
	在当前集合中删除两个集合的交集
	
boolean retainAll(Collection<?> c);
	在当前集合中保留两个集合的交集
	
void clear();
	清空整个集合中的所有元素

查：
int size();
有效元素个数

boolean isEmpty();
	判断当前集合是否为空，是否存在有效元素

boolean contains(Object obj);
	判断指定元素是否在当前集合中存在

boolean containsAll(Collection<?> c);
	判断传入的参数集合是不是当前集合的子集合

Object[] toArray();
	返回集合中所有保存元素的Object类型数组

泛型上限

import java.util.ArrayList;
import java.util.Collection;

class Animal {}

class Dog extends Animal {}

class Cat extends Animal {}

class Flower {}

/*
 * 泛型上限演示
 */
public class Demo3 {
	public static void main(String[] args) {
		Collection<Animal> c1 = new ArrayList<Animal>();
		Collection<Dog> c2 = new ArrayList<Dog>();
		Collection<Cat> c3 = new ArrayList<Cat>();
		
		Collection<Flower> c4 = new ArrayList<Flower>();
		Collection<Object> c5 = new ArrayList<Object>();
		
		/*
		 * 当前方法所需的参数类型是Collection<? extends Animal>
		 * 
		 * 要求参数是一个Collection集合
		 * 要求Collection集合中保存的元素是Animal本身或者其子类对象
		 */
		c1.addAll(c1);
		c1.addAll(c2);
		c1.addAll(c3);
		
		/*
		 * c4 对应的数据类型是Collection<Flower>
		 * 满足当前方法所需数据类型必须是Collection集合，但是不满足
		 * 当前集合中保存元素是Animal本身或者其子类对象的需求。参数错误。
		 */
		// c1.addAll(c4);
		
		/*
		 * c5 对应的数据类型是Collection<Object>
		 * 满足参数要求为Collection集合，但是存储元素是Object类型
		 * 不是Animal的子类
		 */
		// c1.addAll(c5);
		
		
		c1.add(new Animal());
		c1.add(new Dog());
		c1.add(new Cat());
		
		System.out.println(c1);
	}
}

泛型通配符

boolean removeAll(Collection<?> c);
	在当前集合中删除两个集合的交集
	
boolean retainAll(Collection<?> c);
	在当前集合中保留两个集合的交集

boolean containsAll(Collection<?> c);
	判断传入的参数集合是不是当前集合的子集合

? 在当前情况下描述的场景为，不限制传入参数Collection集合中的保存元素。
这里只要求参数类型是Collection，里面保存元素无所谓

集合使用的迭代器

迭代器是操作集合中元素的第二种方式，后期可以延展使用到很多地方，并且存在一个升级版内容。【增强for循环】
迭代器和集合本身有着密切关系，首先迭代器的获取，就是通过集合对象得到对应当前集合的
迭代器。
获取迭代器方法:
Iterator iterator();
获取迭代器对象，泛型对应的具体数据类型和集合中约束的泛型具体数据类型
一致。
迭代器操作使用到的方法：
boolean hasNext();
判断当前集合中是否可以继续得到元素，继续遍历。
E next();
1. 获取迭代器当前指向的元素
2. 将迭代器指向下一个元素
void remove();
删除通过next方法获取到元素
【注意事项】
1. remove方法只能删除next方法获取到元素
2. remove方法只能在next方法之后执行，且不能跨过一个next执行
3. 没有next不能使用remove

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/*
 * 迭代器操作
 */
public class Demo1 {
	public static void main(String[] args) {
		Collection<String> c = new ArrayList<String>();
		
		c.add("雪花纯生");
		c.add("修道院啤酒");
		c.add("1664");
		c.add("泰山精酿");
		c.add("时光精酿");
		
		System.out.println(c);
		
		/*
		 * 获取对应当前集合的迭代器对象
		 * 集合中保存元素是什么类型，迭代器操作元素就是什么类型
		 * 
		 * 迭代器在获取的过程中，默认指向集合中的第一个元素
		 */
		Iterator<String> iterator = c.iterator();
		
		System.out.println("hasNext()方法演示:" + iterator.hasNext());
		System.out.println("next()方法演示:" + iterator.next());
		System.out.println("next()方法演示:" + iterator.next());
		
		System.out.println("remove()执行");
		// 指向迭代器remove方法
		iterator.remove();
		// iterator.remove();
		
		System.out.println(c);
	}
}

迭代器和集合引用数据类型变量冲突问题

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Demo3 {
	public static void main(String[] args) {
		Collection<String> c = new ArrayList<String>();

		c.add("雪花纯生");
		c.add("修道院啤酒");
		c.add("1664");
		c.add("泰山精酿");
		c.add("时光精酿");
		
		/*
		 * 根据当前集合，获取对应的迭代器对象
		 * 
		 * 得到的迭代器对象会依据，当前集合中的所有元素进行一个规划操作。
		 * 迭代器对于整个集合中的元素都是存在预期。
		 */
		Iterator<String> iterator = c.iterator();
		
		/*
		 * 迭代器遍历，利用迭代器的特征进行遍历操作
		 */
		while (iterator.hasNext()) {
			// 获取每一个迭代器指向元素，并且展示
			String string = iterator.next();
			System.out.println(string);
			
			/*
			 * 通过集合对象本身删除1664，对于迭代器而言，一脸懵逼，原本的规划
			 * 没有了！！！并且集合没有告知迭代器数据发生了改变，迭代器继续按照
			 * 原本的规划路径操作，保存！！！
			 * 
			 * 对于集合在内存中占用的空间而言
			 * 	1. 集合对应的引用数据类型变量可以操作对应空间
			 * 	2. 迭代器可以操作对应的空间
			 * 
			 * 对于集合和迭代器而言，【集合在内存中占用的空间】共享资源，在操作
			 * 共享资源过程中，我们要多多考虑共享资源的冲突问题。
			 * 后面课程中会讲到【多线程】
			 */
			c.remove("1664");
		}
		
		/*
		 Exception in thread "main" java.util.ConcurrentModificationException
				at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
				at java.util.ArrayList$Itr.next(ArrayList.java:859)
				at com.qfedu.b_iterator.Demo3.main(Demo3.java:30)
		 */
	}
}