十、Java之Collection集合（1）

1 Collection集合

1.1 集合的由来

集合的由来：
我们学习的是面向对象语言，而面向对象语言对事物的描述是通过对象体现的，为了方便对多个对象进行操作，我们就必须把这多个对象进行存储。而要想存储多个对象，就不能是一个基本的变量，而应该是一个容器类型的变量，在我们目前所学过的知识里面，有哪些是容器类型的呢?
数组和StringBuffer。但是呢?StringBuffer的结果是一个字符串，不一定满足我们的要求，所以我们只能选择数组，这就是对象数组。
而对象数组又不能适应变化的需求，因为数组的长度是固定的，这个时候，为了适应变化的需求，Java就提供了集合类供我们使用。

1.2 数组和集合的区别

* 		A:长度区别
* 			数组的长度固定
* 			集合长度可变
* 		B:内容不同
* 			数组存储的是同一种类型的元素
* 			而集合可以存储不同类型的元素
* 		C:元素的数据类型问题	
* 			数组可以存储基本数据类型，也可以存储引用数据类型
* 			集合只能存储引用类型

1.3 集合的继承体系

集合是存储多元的，但是呢，存储多个元素我们也是有不同需求的：比如说，我要这多个元素中不能有相同的元素，再比如说，我要这多个元素按照某种规则排序一下。针对不同的需求，Java就提供了不同的集合类，这样呢，Java就提供了很多个集合类。这多个集合类的数据结构不同。但是呢，这么多个集合类也是有共性的内容的，我们把这些集合类的共性内容不断的向上提取，最终就能形成集合的继承体系结构。

1.4 Collection的功能概述

 * 1：添加功能
 * 		boolean add(Object obj):添加一个元素
 * 		boolean addAll(Collection c):添加一个集合的元素
 * 2:删除功能
 * 		void clear():移除所有元素
 * 		boolean remove(Object o):移除一个元素
 * 		boolean removeAll(Collection c):移除一个集合的元素(是一个还是所有)
 * 3:判断功能
 * 		boolean contains(Object o)：判断集合中是否包含指定的元素
 * 		boolean containsAll(Collection c)：判断集合中是否包含指定的集合元素(是一个还是所有)
 * 		boolean isEmpty()：判断集合是否为空
 * 4:获取功能
 * 		Iterator<E> iterator()(重点)
 * 5:长度功能
 * 		int size():元素的个数
 * 		面试题：数组有没有length()方法呢?字符串有没有length()方法呢?集合有没有length()方法呢?
 * 6:交集功能
 * 		boolean retainAll(Collection c):两个集合都有的元素?思考元素去哪了，返回的boolean又是什么意思呢?
 * 7：把集合转换为数组
 * 		Object[] toArray()

1.5 Collection集合的遍历

	A:把集合转数组(了解)
	B:迭代器(集合专用方式)

 * Iterator iterator():迭代器，集合的专用遍历方式
 * 		Object next():获取元素,并移动到下一个位置。
 * 			NoSuchElementException：没有这样的元素，因为你已经找到最后了。
 * 		boolean hasNext():如果仍有元素可以迭代，则返回 true。

例子：

public static void main(String[] args) {
	//创建集合对象
	Collection c = new ArrayList();
	
	//创建并添加元素
	c.add("hello");
	c.add("world");
	c.add("java");
	
	//遍历集合
	Iterator it = c.iterator();
	while(it.hasNext()) {
		String s =(String) it.next();
		System.out.println(s);
	}
}

迭代器的原理和源码。
a:为什么定义为了一个接口而不是实现类?
b:看了看迭代器的内部类实现。

public interface Inteator {
	boolean hasNext();
	Object next(); 
}

public interface Iterable {
    Iterator iterator();
}

public interface Collection extends Iterable {
	Iterator iterator();
}

public interface List extends Collection {
	Iterator iterator();
}

public class ArrayList implements List {
	public Iterator iterator() {
        return new Itr();
    }
    
    private class Itr implements Iterator {
    	public boolean hasNext() {}
		public Object next(){} 
    }
}


Collection c = new ArrayList();
c.add("hello");
c.add("world");
c.add("java");
Iterator it = c.iterator();	 //new Itr();
while(it.hasNext()) {
	String s = (String)it.next();
	System.out.println(s);
}

2 List集合

2.1 List概述

List是Collection的子接口
特点：有序(存储顺序和取出顺序一致)，可重复。

2.2 List集合特有功能

 * List集合的特有功能：
 * A:添加功能
 * 		void add(int index,Object element):在指定位置添加元素
 * B:获取功能
 * 		Object get(int index):获取指定位置的元素
 * C:列表迭代器
 * 		ListIterator listIterator()：List集合特有的迭代器
 * D:删除功能
 * 		Object remove(int index)：根据索引删除元素,返回被删除的元素
 * E:修改功能
 * 		Object set(int index,Object element):根据索引修改元素，返回被修饰的元素

2.3 List集合的遍历

迭代器遍历和普通for循环遍历

// 遍历
// 迭代器遍历
Iterator it = list.iterator();
while (it.hasNext()) {
	Student s = (Student) it.next();
	System.out.println(s.getName() + "---" + s.getAge());
}
System.out.println("--------");

// 普通for循环
for (int x = 0; x < list.size(); x++) {
	Student s = (Student) list.get(x);
	System.out.println(s.getName() + "---" + s.getAge());
}

2.4 ListIterator列表迭代器的特有功能

* 列表迭代器：
* 		ListIterator listIterator()：List集合特有的迭代器
* 		该迭代器继承了Iterator迭代器，所以，就可以直接使用hasNext()和next()方法。
* 
* 特有功能：
* 		Object previous():获取上一个元素，可以逆向遍历，但是要先正向遍历，所以无意义，基本不使用。
* 		boolean hasPrevious():判断是否有元素
* 
* 		注意：ListIterator可以实现逆向遍历，但是必须先正向遍历，才能逆向遍历，所以一般无意义，不使用。

2.5 关于ListIterator的一个案例

问题：
有一个集合，请判断里面有没有"world"这个元素，如果有，就添加一个"javaee"元素，请写代码实现。

// 迭代器遍历
Iterator it = list.iterator();
while (it.hasNext()) {
String s = (String) it.next();
if ("world".equals(s)) {
list.add("javaee");

做法错误，会出现ConcurrentModificationException:当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。

 * 产生的原因：
 * 		迭代器是依赖于集合而存在的，在判断成功后，集合的中新添加了元素，而迭代器却不知道，所以就报错了，这个错叫并发修改异常。
 * 		其实这个问题描述的是：迭代器遍历元素的时候，通过集合是不能修改元素的。
 * 如何解决呢?
 * 		A:迭代器迭代元素，迭代器修改元素
 * 			元素是跟在刚才迭代的元素后面的。
 * 		B:集合遍历元素，集合修改元素(普通for)
 * 			元素在最后添加的。

正确的两种做法：

public class ListIteratorDemo2 {
	public static void main(String[] args) {
		// 创建List集合对象
		List list = new ArrayList();
		// 添加元素
		list.add("hello");
		list.add("world");
		list.add("java");

		// 方式1：迭代器迭代元素，迭代器修改元素
		// 结果：元素添加在刚才迭代的位置
		// 而Iterator迭代器却没有添加功能，所以我们使用其子接口ListIterator
		// ListIterator lit = list.listIterator();
		// while (lit.hasNext()) {
		// String s = (String) lit.next();
		// if ("world".equals(s)) {
		// lit.add("javaee");
		// }
		// }

		// 方式2：集合遍历元素，集合修改元素(普通for)
		// 结果：元素添加在集合的末尾
		for (int x = 0; x < list.size(); x++) {
			String s = (String) list.get(x);
			if ("world".equals(s)) {
				list.add("javaee");
			}
		}

		System.out.println("list:" + list);
	}
}

2.6 List集合总结

List:(面试题List的子类特点)
ArrayList:
底层数据结构是数组，查询快，增删慢。
线程不安全，效率高。
Vector:
底层数据结构是数组，查询快，增删慢。
线程安全，效率低。
LinkedList:
底层数据结构是链表，查询慢，增删快。
线程不安全，效率高。

List有三个儿子，我们到底使用谁呢?
	看需求(情况)。
	
要安全吗?
	要：Vector(即使要安全，也不用这个了，后面有替代的)
	不要：ArrayList或者LinkedList
		查询多：ArrayList
		增删多：LinkedList
		
如果你什么都不懂，就用ArrayList。

3 泛型

3.1 泛型的由来

/*
 * 早期的时候，我们使用Object来代表任意的类型。
 * 向上转型是没有任何问题的，但是在向下转型的时候其实隐含了类型转换的问题。
 * 也就是说这样的程序其实并不是安全的。所以Java在JDK5后引入了泛型，提高程序的安全性。
 */
public class ObjectToolDemo {
	public static void main(String[] args) {
		ObjectTool ot = new ObjectTool();

		// 正常使用
		ot.setObj(new Integer(27));
		Integer i = (Integer) ot.getObj();
		System.out.println("年龄是：" + i);

		ot.setObj(new String("林青霞"));
		String s = (String) ot.getObj();
		System.out.println("姓名是：" + s);

		System.out.println("---------");
		ot.setObj(new Integer(30));
		// ClassCastException
		String ss = (String) ot.getObj();
		System.out.println("姓名是：" + ss);
	}
}

/*
 * 泛型类：把泛型定义在类上
 */
public class ObjectTool<T> {
	private T obj;

	public T getObj() {
		return obj;
	}

	public void setObj(T obj) {
		this.obj = obj;
	}
}

ObjectTool<String> ot = new ObjectTool<String>();
// ot.setObj(new Integer(27)); //这个时候编译期间就过不去
ot.setObj(new String("林青霞"));
String s = ot.getObj();
System.out.println("姓名是：" + s);

3.2 泛型概述

1. 泛型：是一种把类型明确的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。参数化类型，把类型当作参数一样的传递。
2. 泛型在哪些地方使用呢?
   看API，如果类，接口，抽象类后面跟的有就说要使用泛型。一般来说就是在集合中使用。
3. 格式：
   <数据类型>
   注意：该数据类型只能是引用类型。
4. 好处：
   A:把运行时期的问题提前到了编译期间
   B:避免了强制类型转换
   C:优化了程序设计，解决了黄色警告线问题，让程序更安全

3.3 泛型类

/*
 * 泛型类：把泛型定义在类上
 */
public class ObjectTool<T> {
	private T obj;

	public T getObj() {
		return obj;
	}

	public void setObj(T obj) {
		this.obj = obj;
	}
}

3.4 泛型方法

/*
 * 泛型方法：把泛型定义在方法上
 * 方法名前要加<T>，不然编译错误
 */
public class ObjectTool {
	public <T> void show(T t) {
		System.out.println(t);
	}
}

3.5 泛型接口

/*
 * 泛型接口：把泛型定义在接口上
 */
public interface Inter<T> {
	public abstract void show(T t);
}

//实现类在实现接口的时候
//第一种情况：已经知道该是什么类型的了

//public class InterImpl implements Inter<String> {
//
//	@Override
//	public void show(String t) {
//		System.out.println(t);
//	}
// }

//第二种情况：还不知道是什么类型的
public class InterImpl<T> implements Inter<T> {

	@Override
	public void show(T t) {
		System.out.println(t);
	}
}

3.6 泛型高级(通配符)

 * 泛型高级(通配符)
 * ?:任意类型，如果没有明确，那么就是Object以及任意的Java类了
 * ? extends E:向下限定，E及其子类
 * ? super E:向上限定，E极其父类

public class GenericDemo {
	public static void main(String[] args) {
		// 泛型如果明确的写的时候，前后必须一致
		Collection<Object> c1 = new ArrayList<Object>();
		// Collection<Object> c2 = new ArrayList<Animal>();
		// Collection<Object> c3 = new ArrayList<Dog>();
		// Collection<Object> c4 = new ArrayList<Cat>();

		// ?表示任意的类型都是可以的
		Collection<?> c5 = new ArrayList<Object>();
		Collection<?> c6 = new ArrayList<Animal>();
		Collection<?> c7 = new ArrayList<Dog>();
		Collection<?> c8 = new ArrayList<Cat>();

		// ? extends E:向下限定，E及其子类
		// Collection<? extends Animal> c9 = new ArrayList<Object>();
		// Animal以及Animal及其子类都可以
		Collection<? extends Animal> c10 = new ArrayList<Animal>();
		Collection<? extends Animal> c11 = new ArrayList<Dog>();
		Collection<? extends Animal> c12 = new ArrayList<Cat>();

		// ? super E:向上限定，E极其父类
		//Animal以及Animal的父类都可以
		Collection<? super Animal> c13 = new ArrayList<Object>();
		Collection<? super Animal> c14 = new ArrayList<Animal>();
		// Collection<? super Animal> c15 = new ArrayList<Dog>();
		// Collection<? super Animal> c16 = new ArrayList<Cat>();
	}
}

class Animal {
}

class Dog extends Animal {
}

class Cat extends Animal {
}

4 JDK5的新特性：自动拆装箱,泛型,增强for,静态导入,可变参数,枚举

4.1 增强for

增强for其实是用来替代迭代器的
举个例子：

反编译后增强for的代码如图所示：

(1)是for循环的一种
(2)格式：
	for(元素的数据类型 变量名 : 数组或者Collection集合的对象) {
		使用该变量即可，该变量其实就是数组或者集合中的元素。
	}
(3)好处：
	简化了数组和集合的遍历
(4)弊端
	增强for循环的目标不能为null。建议在使用前，先判断是否为null。

/*
 * ArrayList存储字符串并遍历。要求加入泛型，并用增强for遍历。
 * A:迭代器
 * B:普通for
 * C:增强for
 */
public class ArrayListDemo {
	public static void main(String[] args) {
		// 创建集合对象
		ArrayList<String> array = new ArrayList<String>();

		// 创建并添加元素
		array.add("hello");
		array.add("world");
		array.add("java");

		// 遍历集合
		// 迭代器
		Iterator<String> it = array.iterator();
		while (it.hasNext()) {
			String s = it.next();
			System.out.println(s);
		}
		System.out.println("------------------");

		// 普通for
		for (int x = 0; x < array.size(); x++) {
			String s = array.get(x);
			System.out.println(s);
		}
		System.out.println("------------------");

		// 增强for
		for (String s : array) {
			System.out.println(s);
		}
	}
}

4.2 静态导入(了解)

 * 静态导入：
 * 格式：import static 包名….类名.方法名;
 * 可以直接导入到方法的级别
 * 
 * 静态导入的注意事项：
 * 		A:方法必须是静态的
 * 		B:如果有多个同名的静态方法，容易不知道使用谁?这个时候要使用，必须加前缀。由此可见，意义不大，所以一般不用，但是要能看懂。

4.3 可变参数(掌握)

(1)如果我们在写方法的时候，参数个数不明确，就应该定义可变参数。
(2)格式：
	修饰符 返回值类型 方法名(数据类型... 变量) {}
	
	注意：
		A:该变量其实是一个数组名
		B:如果一个方法有多个参数，并且有可变参数，可变参数必须在最后
(3)Arrays工具类的一个方法
	asList()把数组转成集合。
	注意：这个集合的长度不能改变。

举个例子：
Arrays.asList(a)

/*
 * public static <T> List<T> asList(T... a):把数组转成集合
 * 
 * 注意事项：
 * 		虽然可以把数组转成集合，但是集合的长度不能改变。
 */
public class ArraysDemo {
	public static void main(String[] args) {
		// 定义一个数组
		// String[] strArray = { "hello", "world", "java" };
		// List<String> list = Arrays.asList(strArray);

		List<String> list = Arrays.asList("hello", "world", "java");
		// UnsupportedOperationException
		// list.add("javaee");
		// UnsupportedOperationException
		// list.remove(1);
		list.set(1, "javaee");

		for (String s : list) {
			System.out.println(s);
		}
	}
}