集合笔记（超详细）

课程内容

1、集合的概述
2、Collection
3、List
4、Arraylist、LinkedList、Vector
5、泛型
6、Set
7、Map
8、Collections工具类
9、斗地主的制牌、洗牌和发牌

集合的体系结构

1、集合分类：
 	单列集合：每个元素都是一个单独的个体
 	双列集合：每个操作都是针对一对数据来进行的，一对数据作为
 	一个单位
2、单列集合的体系：
 	Collection					单列集合的顶层接口
 	 	List						有序的子接口
 	 	 	ArrayList 	 	 	顺序存储，查询修改块
 	 	 	LinkedList				链式存储，增加删除块
 	 	 	Vector 	 	 	 	顺序存储，都慢
 	 	Set						无序的子接口
 	 	 	HashSet				哈希存储
 	 	 	 	LinkedHashSet
3、双列结合的体系：
 	Map							双列集合的顶层接口
 	 	HashMap 	 	 	 	哈希表存储
 	 	 	LinkedHashMap

Collection

1、单词：收集、集合
2、单列集合的顶层接口，定义的是所有单列集合中共有的功能。
3、Collection是一个接口，不能直接创建对象，随意找一个实现类
   创建对象
 	使用接口类型的引用，指向实现类的对象
 	Collection类型的引用，指向 ArrayList类型的对象（只能调
 	用接口中的方法）
4、常用方法：
 	add(Object obj)：将obj元素添加到集合中
 	remove(Object obj)：将obj元素从集合中删除
 	clear()：将集合中的元素清空
 	isEmpty()：判断集合是否为空
 	contains(Object obj)：判断集合中是否包含obj元素
    size()：返回集合中的元素个数

Collection的第一种遍历方式

1、转成数组，通过遍历数组的方式，来间接的遍历集合
2、Object[] toArray()：将调用者集合转成Object类型的数组

package com.ujiuye.demos;

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

public class Demo03_Collection的第一种遍历方式 {

	public static void main(String[] args) {
		Collection persons = new ArrayList();
		persons.add(new Person("zhangsan", 23));
		persons.add(new Person("lisi", 24));
		persons.add(new Person("wangwu", 25));
		persons.add(new Person("zhaoliu", 26));
		//转成Object数组
		Object[] objs = persons.toArray();
		//遍历数组
		for (int i = 0; i < objs.length; i++) {
			//由于在存储的时候，就提升成了Object类型，所以取
			出也是Object类型
			Object obj = objs[i];
			//向下转型，转型之后才能调用Person类中的方法
			Person p = (Person)obj;
			System.out.println(p.getName() + "..." +
			 p.getAge()); 
		}
	}

	private static void test1() {
		Collection c = new ArrayList();
		c.add(123);
		c.add(234);
		c.add(666);
		c.add("abc");
		c.add("xyz");
		
		//转成Object类型的数组
		Object[] objs = c.toArray();
		//通过遍历数组的方式，间接的遍历集合
		for (int i = 0; i < objs.length; i++) {
			System.out.println(objs[i]);
		}
	}
}

Collection中带all的方法

1、addAll(Collection c)：将参数c中的所有元素，都添加到调用
   者集合中
2、removeAll(Collection c)：从调用者集合中，删除那些也存在
   于参数c中的元素
3、containsAll(Collection c)：判断调用者，是否能包含参数c中
   的所有元素
4、retainAll(Collection c)：参数c中有哪些元素，就在调用者集
   合中，保留哪些元素（交集）

集合遍历的第二种方式：迭代器

1、迭代：更迭、更新换代，有从某一个到下一个的过程的含义

2、迭代器：专门用于将集合中的元素，一个到另一个逐个进行迭代的
   对象
   
3、获取：集合自己内部就应该有一个可以迭代自己的对象，从集合对
   象中获取即可
 	Iterator  iterator()
 	
4、迭代器的使用：
 	方法iterator返回的是一个Iterator接口的实现类对象，可以
 	使用的就是Iterator接口中的方法：
 	hasNext()：判断集合中是否还有下一个元素
 	next()：获取集合中的下一个元素
 	remove()：删除迭代器对象正在迭代的那个对象
 	
5、迭代器的注意事项：

 	1、迭代器对象虽然多次调用next方法，都是同样的方法名称，
 	   但是每次调用返回的结果是不同的，会因为next方法既可以
 	   获取下一个元素，也会让迭代器对象，向前移动一步。
 	   
 	2、如果没有下一个元素，仍然调用next方法，出现           
 	   NoSuchElementException（没有当前元素异常），
 	   可以使用hasNext方法判断是否有下一个元素，
 	   决定是否调用next方法
 	   
 	3、hasNext方法，判断是否有下一个元素，不会移动迭代器位置
 	
 	4、next方法，不仅可以获取下一个元素，还会移动迭代器位置
 	
 	5、不要只判断一次hasNext，就调用多次next方法

package com.ujiuye.demos;

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

public class Demo05_Collection的第二种遍历方式迭代器 {

	public static void main(String[] args) {
		Collection persons = new ArrayList();
		persons.add(new Person("zhangsan", 23));
		persons.add(new Person("lisi", 24));
		persons.add(new Person("wangwu", 25));
		persons.add(new Person("zhaoliu", 26));
		//获取迭代器对象
		Iterator it = persons.iterator();
		//反复判断是否有下一个元素（迭代器对象在不断的移动）
		while(it.hasNext()) {
	     	//获取下一个元素并且强转
			Person p = (Person)(it.next());
			
			System.out.println(p.getName() + "..." +
			 p.getAge());
		}
	}

	private static void test1_迭代器试用() {
		Collection c = new ArrayList();
		c.add(123);
		c.add(456);
		c.add(666);
		
		//获取集合的迭代器对象
		Iterator it = c.iterator();
		System.out.println(it.hasNext());
		System.out.println(it.next());
		System.out.println(it.hasNext());
		System.out.println(it.next());
		System.out.println(it.hasNext());
		System.out.println(it.next());
		System.out.println(it.hasNext());
		System.out.println(it.next());
	}
}

List

1、是Collection的一个子接口
2、特点：
 	有序：每个元素都有自己的位置，不同位置是有分别的
 	【有索引】：每个元素都有自己的编号
 	可以重复：即使是值相同的几个元素，位置和索引也各不相同，
 	可以区分这几个值。
3、特有方法：
 	add(int index, Object obj)：在指定索引上，添加指定元素
 	remove(int index)：删除指定索引上的值
 	set(int index, Object obj)：将指定索引上的值，
 	修改为指定的值
 	get(int index)：根据给定的索引，获取对应位置的值

package com.ujiuye.demos;

import java.util.ArrayList;
import java.util.List;

public class Demo06_List特有方法 {

	public static void main(String[] args) {
		
	}

	private static void test1_List的特有方法() {
		List list = new ArrayList();
		list.add(0, "abc");
		list.add(0, "xyz");
		list.add(1, "666");
		System.out.println(list);
		
		list.remove(1);
		System.out.println(list);
		
		list.set(1, "def");
		System.out.println(list);
		
		System.out.println(list.get(0));
	}
}

第三种遍历方式

1、针对List集合特有的遍历方式
2、可以通过集合的size方法获取list集合索引的范围，根据索引
   通过get方法可以获取指定索引的值。

package com.ujiuye.demos;

import java.util.ArrayList;
import java.util.List;

public class Demo07_第三种遍历方式 {

	public static void main(String[] args) {
		List list = new ArrayList();
		list.add("abc");
		list.add("abc");
		list.add("abc");
		list.add("def");
		list.add("def");
		list.add("def");
		list.add("qq");
		for (int i = 0; i < list.size(); i++) {
			String str = (String)(list.get(i));
			System.out.println(str);
		}
	}
}

并发修改异常

1、ConcurrentModificationException
 	并发       修改      异常
 	
2、出现原因：
 	在使用【迭代器对象】遍历集合的同时，使用【集合对象】增加
 	集合的元素
 	
3、解决方法：两种解决方式都是针对List集合可以解决
 	方式1：迭代器遍历、迭代器增加
 	方式2：集合遍历、集合增加
 	
4、解决方式1：迭代器遍历、迭代器增加
 	迭代器遍历，和以前一样
 	迭代器增加：问题普通的迭代器中没有增加的方法，需要使用
 	List中特有的迭代器
 	列表迭代器：ListIterator，是Iterator的子接口，拥有
 	Iterator中的所有方法，还有特有
 	列表迭代器的获取：listIterator()
 	
5、解决方式2：集合遍历、集合添加
 	集合遍历：list特有的方式遍历，size和get方法结合
 	集合添加：集合的add方法

package com.ujiuye.demos;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class Demo08_并发修改异常 {

	public static void main(String[] args) {
		List list = new ArrayList();
		list.add(111);
		list.add(111);
		list.add(222);
		list.add(333);
		list.add(444);
		list.add(555);
		list.add(555);
		
		test3_集合遍历集合添加(list);
		
	}

private static void test3_集合遍历集合添加(List list) {
		for(int i = 0; i < list.size(); i++) {
			Object obj = list.get(i);
			if (obj.equals(222)) {
				list.add(666);
			}
		}
		System.out.println(list);
	}

private static void test2_迭代器遍历迭代器添加(List list){
		//第一种解决思路：迭代器遍历，迭代器增加
		ListIterator lit = list.listIterator();
		while(lit.hasNext()) {
			Object obj = lit.next();
			if (obj.equals(222)) {
				lit.add(666);
			}
		}
		System.out.println(list);
	}

	private static void test1_并发修改异常(List list) {
		Iterator it = list.iterator();
		while(it.hasNext()) {
			Object obj = it.next();
			//判断如果这个数字是222，就在集合中添加一个666
			if (obj.equals(222)) {
//				list.add(666);
//				list.set(0, 666);
				list.remove(555);
			}
		}
		System.out.println(list);
	}

}

List的实现类

1、List只是一个接口，根据底层实现方式的不同，具有不同的实现类
2、ArrayList：数组实现，顺序存储
3、LinkedList：节点实现，链式存储
4、Vector：数组实现，顺序存储

ArrayList

1、也是List的一个实现类
2、没有什么特有方法
3、存储方式：
 	数组实现，顺序存储
 	通过物理内存的位置关系，来表达描述逻辑顺序的相邻

LinkedList

1、List的一个实现类

2、存储方式：
 	节点实现，链式存储
 	不通过物理内存位置的相邻，来表示逻辑顺序的相邻
 	每个元素都存储在一个节点中，节点除了元素数据本身以外，还
 	需要存储下一个元素的内存地址
 	
3、特点：
 	查询速度慢：需要根据前面的节点来获取后一个节点的地址，前
 	面所有节点都要访问一遍，节点数量越多，查询虚度越慢
 	增删速度快：增删一个元素，只需要修改新增元素前后的两个
 	节点的引用域即可，与集合本身的元素个数无关。
 	
4、LinkedList的特有方法：
 	由于在LinkedList中，维护了链表的头和尾节点的对象地址，
 	所以操作头部和尾部非常容易，提供了大量的操作头和尾的方法。
 	addFirst(Object obj)：在头部添加元素
 	addLast(Object obj)：在尾部添加元素
 	removeFirst()：删除头部元素
 	removeLast()：删除尾部元素
 	getFirst()：获取头部元素
 	getLast()：获取尾部元素

泛型

1、泛型：广泛的类型，在定义一个类的时候，类型中有些方法参数、
   返回值类型不确定，就使用一个符号，来表示那些尚未确定的类型
   ，这个符号，就称为泛型。
2、使用：对于有泛型的类型，在这些类型后面跟上尖括号，尖括号
   里面写上泛型的确定类型（在使用某个类创建对象时，已经可以
   确定这个具体的类型了，那么就直接写出具体类型）
   ArrayList<Integer> al = new ArrayList<Integer>();
3、泛型的好处：
 	1、提高了数据的安全性，将运行时的问题，提前暴露在编译时期
 	2、避免了强转的麻烦
4、注意事项： 
 	1、前后一致：在创建对象时，赋值符号前面和后面的类型的泛型
 	   ，必须一致
 	2、泛型推断：如果前面的引用所属的类型已经写好了泛型，后面
 	   创建对象的类型就可以只写一个尖括号，尖括号中可以不写任
 	   何内容。<>特别像菱形，称为“菱形泛型”