七.有容乃大 -- Java 集合（List/Set/Map）

集合框架
学习方法 【知识点的理解和认识】
(1) 执行流程[顺序 选择 循环]—>独立的方法的使用，对象：线程
(2) 面向对象的编程思想
将具有相同属性和行为的事物抽象出来，划分为类。每一个具体的事物就是一个对象，类是封装对象的属性和行为的载体，是构造对象的规范，对象即是类的实例。
(3) 计算机 是按照程序高速处理海量数据的现代化电子设备
(4) Java代码其实就是在处理数据
数据存储方式的回顾
(1) 变量：存储单个数据
(2) 数组：存储多个数据
设计一个容器类[基于数组实现的容器类]：掌握思想
(1) 实际就是对数组或变量的封装，底层就是对数组和变量进行操作
设计了，查找，删除的方法：体现设计代码：面向对象
链表结构的概念
(1) 单独设计一个节点类：存储数据的变量、存储下一个节点的地址的变量
(2) 每一添加一个元素就是新创建了一个节点，然后让上一个节点保存新创建节点的地址。
基于变量实现链表结构：掌握思想：看懂代码一样重要
LIST
1、集合框架
(1) 在Java中已经设计好了一些类和接口，和我们之前模拟的容器类功能一样。实现了对底层数组和聊表结果的封装操作。这些类在Java中，我们叫做集合;
2、ArrayList类
(1) 概念：
① ArrayList是基于数字实现的，底层是对数组的操作
② 实现了可选列表操作，可插入null值
③ 便于元素的查找可修改
④ 线程不安全的，可通过封装实现线程同步
List list = Collections.synchronizedList(new ArrayList(…));
(2) 构造方法
① ArrayList();构造一个初试容量为0 的空列表，JDK1.6为10，JDK1.8为0；
② ArrayList(int i);构造一个初试容量为i 的空列表
③ ArrayList(Collection <? extends E> c);构造一个包含Collection列表中所有元素的列表
(3) 普通方法
① void add(E e);将指定元素添加到列表结尾
② void add(int index,E e);在指定索引位置插入指定元素
③ void addAll(Collection <? extends E> c);将Collection列表中的所有元素添加到列表结尾
④ void addAll(int index,Collection <? extends E> c);将Collection列表中的所有元素添加到列表指定索引处
⑤ void clear();清空列表中的元素
⑥ boolean contains(Object obj);判断集合列表中是否有指定元素
⑦ void ensureCapacity(int i);将列表增加指定的容量
⑧ E get(int index);返回指定索引的元素
⑨ int indexOf(Object obj);返回指定元素在列表中首次出现的索引
⑩ boolean isEmpty();判断集合列表是否为空，空返回true，非空返回false
11 int lastIndexOf(Object obj);返回指定元素在列表中最后一个出现的索引
12 E remove(int index);返回指定索引的元素，并返回
13 boolean remove(Object obj);删除集合中首次出现的指定元素，若想删除int型的元素，为避免与方法的索引值冲突，则应将int型数据包装为Integer或Object型。
14 E set(int index,E element);用指定元素替代指定索引的元素
15 int size();返回集合列表的元素个数
16 object[] toArray();返回集合的数组形式
17 void trimTosize()；去掉多余的容量
3、LinkedList类
(1) 概念：
① LinkedList是基于链表实现的，每添加一个元素都会创建一个节点
② LinkedList便于快速的插入和删除元素
③ LInkedList提供了额外的 get 、remove、 insert方法对链表的头，尾进行操作
④ LinkedList可以作为：堆栈 FILO 队列 排队：FIFO 双端队列
⑤ 实现了可选列表操作，都可插入null值
⑥ LinkedList都是线程不安全的，但可以通过包装来保持同步
List list = Collections.synchronizedList(new LinkedList(…));
(2) 构造方法
① LinkedList();构造空列表
② LinkedList(Collection <? extends E> c);构造一个包含Collection列表中所有元素的列表
(3) 普通方法
① E element();获取但不移除列表头，若列表为空，则抛出异常
② E peek();获取但不移除列表头，若列表为空，则返回null
③ E pop();获取并弹出列表头，若列表为空，则抛出异常
④ E poll();获取并弹出列表头，若列表为空，则返回null
⑤ 其他方法与ArrayList类似
4、集合的遍历

LinkedList<String> list = new LinkedList<String>();
		list.add("A");
		list.add("B");
		list.add("C");
		list.add("D");
		list.add("E");
		System.out.println(list);
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.pop());
		}

(1) toArray()
eg:

String[] str = list.toArray();
for(String s : str){
System.out.println(s);
}

(2) for
eg:

for(int i = 0;i < list.size();i ++){
System.out.println(list.get(i));
}

(3) foreach
eg:

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

(4) 单向迭代
集合实现了 Iterable接口
获取迭代器 Iterator iterator()
使用：
boolean hasNext();判断是否有下一个元素
E next();返回下一个元素
eg:

Iterator iterator = list.iterator();
while(iterator.hasNext()){
System.out.println(list.next());
}

(5) 双向迭代
获取迭代器
ListIterator li = 集合名.listIterator();
正向
boolean hasNext()
E next()
逆向
boolean hasPrevious() ;是否有上一个元素
E previous();返回上一个元素
eg:

ListIterator li = list.listIterator();
//正向迭代
while(li.hasNext()){
System.out.println(li.next());
}
//反向迭代
while(li.hasPrevious()){
System.out.println(li.prebious());
}

SET&COLLECTION体系
1、Set接口
(1) 存储不重复的，无序的【添加顺序与迭代顺序不同】元素
(2) 要保证添加进Set中的元素不重复，必须重写对象的hashCode()方法和equals()方法
(3) 存储方式：在添加对象时，实现调用对象的hashCode()方法，计算对象的hash值，此哈希值决定了对象的存储位置。若计算的hash值位置没有元素，则直接将元素存放在该位置上，若该位置有元素，组调用元素的equals()方法，对元素进行比较，，若两个对象相同，则表示是重复的对象，不在添加。
(4) 可用迭代器迭代。
2、HashSet类
(1) 概念：
① Set接口的实现类，存储不重复的，无序的元素
② 可存储多种类型的元素【对象】,亦可存放任意类型的元素
③ 线程不安全的，但可通过封装得到线程安全得到对象
Set s = Collections.synchronizedSet(new HashSet(…));
(2) 判断元素重复的标准
通过比较两个或多个对象的hash值和equals()的返回值：
若两个或多个对象的hash值相同，且equals()返回值为true，则表示元素重复。

注：需要自己重写hashCode()方法和equals()方，equals()方法比较的是对象的字段值是否相等。
3、TreeSet类
(1) 概念
① Set接口的实现类，存储不重复的，无序的元素
② 一旦添加一种类型的元素，则不能添加其他类型的元素，即只能存储一种类型的元素，但可以是任意类型
③ 线程不安全的，但可通过包装得到线程安全的对象：
Set s = Collections.synchronizedSet(new TreeSet(…));
④ 要添加进TreeSet集合的元素【对象】必须具有自然排序的能力，即实现Comparable接口，并重写了compareTo()方法【定制自然排序的规则】。若没有实现Comparable接口，则添加此元素的TreeSet集合必须添加了定制比较器
⑤ 可使用迭代器迭代
(2) 自然排序
① 实现Comparable接口【使对象具有自然排序的能力】，并重写compareTo()方法【定制自然排序的规则】
② java自带的类型基本都实现了Comparable接口， 如Integer、String等。
③ 开发人员自定义的类型的对象则必须手动实现Comparable接口【使对象具有自然排序的能力】，并重写了compareTo()方法【定制自然排序的规则】
(3) 定制比较器
① 类本身没有排序能力，若没有实现Comparable接口，则需要给集合指定定制比较器
② 用户自定义的类型实现Comparator接口，重写compare()方法【制定排序规则】
③ 若某个类即实现了自然排序，有指定了定制比较器，则优先使用定制比较器
④ 实现方式：

自定义一个比较器类，实现Comparator接口，实现compare()方法
eg:

/*
 *自定义比较器类，实现Comparator接口，重写compare()方法
 */
public class MyComparator implements Comparator{
	@Override
	public int compare(Object o1, Object o2) {
		if (o1 instanceof Customer && o2 instanceof Customer) {
			Customer cs1 = (Customer)o1;
			Customer cs2 = (Customer)o2;
			if (cs1.getID().intValue() > cs2.getID().intValue()) {
				System.out.println(">");
				return -1;
			}else if (cs1.getID().intValue() < cs2.getID().intValue()) {
				System.out.println("<");
				return 1;
			}else {
				System.out.println("+");
				return cs1.getName().compareTo(cs2.getName());
			}	
		}
		return 0;
	}
}

创建Comparator接口的匿名内部类对象，重写compare()方法
eg:

		/*
		 * 创建匿名内部类，返回Comparator接口的实现子类
		 */
		Comparator comparator = new Comparator() {
			@Override
			/*
			 * 重写compare()方法
			 */
			public int compare(Object o1, Object o2) {
				if (o1 instanceof Customer && o2 instanceof Customer) {
					Customer cs1 = (Customer)o1;
					Customer cs2 = (Customer)o2;
					if (cs1.getID().intValue() > cs2.getID().intValue()) {
						System.out.println(">");
						return 1;
					}else if (cs1.getID().intValue() < cs2.getID().intValue()) {
						System.out.println("<");
						return -1;
					}else {
						System.out.println("=");
						return cs1.getName().compareTo(cs2.getName());
					}	
				}
				return 0;
			}
		}