# 概述
通过该笔记的整理，对 `JAVA` 的 `Collection`（集合）的基本使用和一些常见的使用场景、底层源码等知识点进行巩固，以达到 “温故知新” 的目的。
# 目录
[TOC]
# 主要内容
## 0x01：集合框架的概述
面向对象语言对事物的体现都是以对象的形式，为了方便对多个对象的操作，就要对对象进行存储。另一方面，使用 `Array` 存储对象方面具有一些弊端，而`Java` 集合就像一种容器，可以动态地把多个对象的引用放入容器中。
- 数组在存储多个数据方面的特点：
- 一旦初始化以后，其长度就确定了。
- 数组一旦定义好，其元素的类型也就确定了。我们也就只能操作指定类型的数据了。
- 数组在存储多个数据方面的缺点：
- 一旦初始化以后，其长度就不可修改。
- 数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高。
- 获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用
- 数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足。
使用集合可以解决上述数组在储存多个数据时的缺点。
而 `Java` 集合类可以用于存储数量不等的多个对象，还可用于保存具有映射关系的关联数组。
`Java` 集合可分为 `Collection` 和 `Map` 两种体系
- Collection接口： 单列数据， 定义了存取一组对象的方法的集合
- List： 元素有序、可重复的集合
- ArrayList、LinkedList、Vector
- Set： 元素无序、不可重复的集合
- HashSet、LinkedHashSet、TreeSet
- Map接口： 双列集合，可以储存双列数据，保存具有映射关系 “key-value” 的集合
- HashMap、LinkedHashMap、TreeMap、Hashtable、Properties
Collection接口继承树
Map接口继承树
## 0x02：Collection接口中的常用方法
Collection 接口是 `List`、 `Set` 和 `Queue` 接口的父接口，该接口里定义的方法既可用于操作 `Set` 集合，也可用于操作 `List` 和 `Queue` 集合。
`JDK` 不提供此接口的任何直接实现，而是提供更具体的子接口 (如： `Set`和 `List`)实现。
在 `JDK5` 之前， Java 集合会丢失容器中所有对象的数据类型，把所有对象都当成 `Object` 类型处理； 从 `JDK 5.0` 增加了泛型以后， `Java` 集合可以记住容器中对象的数据类型。
一些常用的方法如下
1、 添加
- `add(Object obj)`
- `addAll(Collection coll)`
2、 获取有效元素的个数
- `int size()`
3、 清空集合
- `void clear()`
4、 是否是空集合
- `boolean isEmpty()`
5、 是否包含某个元素
- `boolean contains(Object obj)`：
是通过元素的equals方法来判断是否是同一个对象
- `boolean containsAll(Collection c)`：
也是调用元素的equals方法来比较的。 拿两个集合的元素挨个比较。
6、删除
- `boolean remove(Object obj)` ：
通过元素的equals方法判断是否是要删除的那个元素。 只会删除找到的第一个元素
- `boolean removeAll(Collection coll)`：
取当前集合的差集
7、取两个集合的交集
- `boolean retainAll(Collection c)`：
把交集的结果存在当前集合中，不影响c
8、 集合是否相等
- `boolean equals(Object obj)`
9、 转成对象数组
- `Object[] toArray()`
10、获取集合对象的哈希值
- `hashCode()`
11、遍历
- `iterator()`：
返回迭代器对象，用于集合遍历
部分用例代码如下
```java
public class CollectionTest {
@Test
public void test1(){
Collection coll = new ArrayList();
//add(Object e):将元素e添加到集合coll中
coll.add("AA");
coll.add("BB");
coll.add(123);//自动装箱
coll.add(new Date());
//size():获取添加的元素的个数
System.out.println(coll.size());//4
//addAll(Collection coll1):将coll1集合中的元素添加到当前的集合中
Collection coll1 = new ArrayList();
coll1.add(456);
coll1.add("CC");
coll.addAll(coll1);
System.out.println(coll.size());//6
System.out.println(coll);
//clear():清空集合元素
coll.clear();
//isEmpty():判断当前集合是否为空
System.out.println(coll.isEmpty());
}
}
```
## 0x02：Iterator 迭代器
### 概述
- `Iterator` 对象称为迭代器(设计模式的一种)，主要用于遍历 `Collection` 集合中的元素。
- `GOF` 给迭代器模式的定义为：提供一种方法访问一个容器(`container`)对象中各个元素，而又不需暴露该对象的内部细节。 迭代器模式，就是为容器而生。 类似于“公交车上的售票员”、“火车上的乘务员”、 “空姐” 。
- Collection 接口继承了 `java.lang.Iterable` 接口，该接口有一个`iterator()` 方法，那么所有实现了 `Collection` 接口的集合类都有一个iterator() 方法，用以返回一个实现了 `Iterator` 接口的对象。
### 遍历
使用 `iterator`（迭代器)遍历集合
```java
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new Person("Jerry",20));
coll.add(new String("Tom"));
coll.add(false);
Iterator iterator = coll.iterator();
//hasNext():判断是否还有下一个元素
while(iterator.hasNext()){
//next():①指针下移 ②将下移以后集合位置上的元素返回
System.out.println(iterator.next());
}
```
输出结果
```
123
456
Person{name='Jerry', age=20}
Tom
false
```
迭代器的遍历原理：
- 获取集合的迭代器对象
- 每次调用迭代器的 `.next()` 方法时，先使用 `hasNext` 下一个对象是否存在，再将指针（游标）指向迭代器中的下一个对象，然后返回当前指向的对象的值，如下图
Iterator 仅用于遍历集合， `Iterator` 本身并不提供承装对象的能力。如果需要创建 `Iterator` 对象，则必须有一个被迭代的集合。
**错误的示范：**
```java
//错误方式一：
Iterator iterator = coll.iterator();
while((iterator.next()) != null){
System.out.println(iterator.next());
}
//错误方式二：
//集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。
while (coll.iterator().hasNext()){
System.out.println(coll.iterator().next());
}
```
集合对象每次调用 `iterator()` 方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。所以 `hasNext()` 和 `next()` 都调用都必须处于同一个迭代器对象下。
#### 使用foreach进行遍历
`Java 5.0` 提供了 `foreach` 循环迭代访问 Collection和数组。
- 遍历操作不需获取Collection或数组的长度，无需使用索引访问元素。
- 遍历集合的底层调用 `Iterator` 完成操作。
- foreach还可以用来遍历数组。
编辑集合
```java
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new Person("Jerry",20));
coll.add(new String("Tom"));
coll.add(false);
//for(集合元素的类型 局部变量 : 集合对象)
//内部仍然调用了迭代器。
for(Object obj : coll){
System.out.println(obj);
}
```
遍历数组
```java
int[] arr = new int[]{1,2,3,4,5,6};
//for(数组元素的类型 局部变量 : 数组对象)
for(int i : arr){
System.out.println(i);
}
```
练习题：使用 `foreach` 遍历的数组，重新赋值不会影响原数组的值，如下
```JAVA
String[] arr = new String[]{"MM","MM","MM"};
//方式一：普通for赋值
for(int i = 0;i < arr.length;i++){
arr[i] = "GG";
}
//方式二：增强for循环
for(String s : arr){
s = "FF";
}
for(int i = 0;i < arr.length;i++){
System.out.println(arr[i]);
}
```
输出结果
```
GG
GG
GG
```
原因：使用foreach遍历数组时，遍历时会产生新的对象用于接收原有的值
### 移除
- 调用 `.remove()` 方法
```java
//删除集合中"Tom"
Iterator iterator = coll.iterator();
while (iterator.hasNext()){
//iterator.remove();
Object obj = iterator.next();
if("Tom".equals(obj)){
iterator.remove();
//iterator.remove();
}
}
//遍历集合
iterator = coll.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
```
注意：
- `Iterator` 可以删除集合的元素， 但是是遍历过程中通过迭代器对象的 `remove` 方法， 不是集合对象的 `remove` 方法。
- 如果还未调用 `next()` 或在上一次调用 `next` 方法之后已经调用了 `remove` 方法，再调用 remove 都会报 `IllegalStateException`。
## 0x03：List接口
### 概述
鉴于 `Java` 中数组用来存储数据的局限性，我们通常使用List替代数组
`List` 集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引。
`List` 容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。
`JDK API` 中 `List` 接口的实现类常用的有： ArrayList、 LinkedList和Vector。
### 实现类：ArrayList
`JDK7` 与 `JDK8` 的情况会有些不同，我们继续具体的分析
**JDK7 的情况下：**
初始化 `ArrayList`
```java
ArrayList list = new ArrayList();
```
底层创建了长度是 `10` 的 `Object[]` 数组`elementData` 如下图
接着往list内添加数据
```java
list.add(123); //elementData[0] = new Integer(123);
```
如果此时继续向 `list` 内添加数据，导致底层 `elementData` 数组容量不够，则会进行扩容。
默认情况下，扩容为原来的容量的1.5倍，同时需要将原有数组中的数据复制到新的数组中。
> 扩容的方式与SpringBuilder类似
结论：建议开发中使用带参的构造器：`ArrayList list = new ArrayList(int capacity)`，并指定一个预期的容量大小，以减少扩容的次数。
**JDK8 的情况下：**
初始化 `ArrayList`
```
ArrayList list = new ArrayList();
```
此时底层 `Object[] elementData` 初始化为 `{}` .并没有创建长度为 `10` 的数组
> 在JDK8的源码的当中，代码改了，但是注释没改 😂
```
list.add(123); //向list添加数据
```
第一次调用 `add()` 时，底层才创建了长度 `10` 的数组，并将数据 `123` 添加到 `elementData[0]`
后续的添加和扩容操作与 `jdk 7` 无异。
**小结：**
`jdk7` 中的 `ArrayList` 的对象的创建类似于单例的 “饿汉式” ，而 `jdk8` 中的 `ArrayList` 的对象的创建类似于单例的懒汉式，延迟了数组的创建，节省内存。
### 实现类：LinkedList
对于频繁的插入或删除元素的操作，建议使用 `LinkedList` 类，效率较高，对于需要频繁读取（查询）的操作，还是建议使用 `ArrayList`
LinkedList： 双向链表， 内部没有声明数组，而是定义了 `Node` 类型的 `first`和`last`，用于记录首末元素。同时，定义内部类 `Node`，作为 `LinkedList` 中保存数据的基本结构。 `Node ` 除了保存数据，还定义了两个变量：
- prev 变量记录前一个元素的位置
- next 变量记录下一个元素的位置
源码如下
```java
private static class Node<E> {
E item;
Node<E> next;
Node<E> prev;
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
```
新增方法：
- void addFirst(Object obj)
- void addLast(Object obj)
- Object getFirst()
- Object getLast()
- Object removeFirst()
- Object removeLast()
一些资料：[不要用for循环去遍历LinkedList](https://www.cnblogs.com/zhilu-doc/p/5292818.html)
### 实现类：Vector
`Vector` 是一个古老的集合， `JDK1.0` 就有了。大多数操作与 `ArrayList`相同，区别之处在于 `Vector` 是线程安全的。
`jdk7` 和 `jdk8 `中通过 Vector() 构造器创建对象时，底层都创建了长度为 `10` 的数组。在扩容方面，默认扩容为原来的数组长度的 `2` 倍。
在各种 `list` 中，最好把 `ArrayList` 作为缺省选择。当插入、删除频繁时，使用LinkedList， `Vector` 总是比 `ArrayList` 慢，所以尽量避免使用。
新增方法：
- void addElement(Object obj)
- void insertElementAt(Object obj,int index)
- void setElementAt(Object obj,int index)
- void removeElement(Object obj)
- void removeAllElements()
### 常用的方法及使用
- `void add(int index, Object ele)`:
在index位置插入ele元素
- `boolean addAll(int index, Collection eles)`:
从index位置开始将eles中的所有元素添加进来
- `Object get(int index)`:
获取指定index位置的元素
- `int indexOf(Object obj)`:
返回obj在集合中首次出现的位置
- `int lastIndexOf(Object obj)`:
返回obj在当前集合中末次出现的位置
- `Object remove(int index)`:
移除指定index位置的元素，并返回此元素
- `Object set(int index, Object ele)`:
设置指定index位置的元素为ele
- `List subList(int fromIndex, int toIndex)`:
返回从fromIndex到toIndex位置的子集合
使用案例 ①
```java
@Test
public void test1(){
ArrayList list = new ArrayList();
list.add(123);
list.add(456);
list.add("AA");
list.add(new Person("Tom",12));
list.add(456);
System.out.println(list);
//void add(int index, Object ele):在index位置插入ele元素
list.add(1,"BB");
System.out.println(list);
//boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
List list1 = Arrays.asList(1, 2, 3);
list.addAll(list1);
//list.add(list1);
System.out.println(list.size());//9
//Object get(int index):获取指定index位置的元素
System.out.println(list.get(0));
}
```
输出结果
```java
[123, 456, AA, Person{name='Tom', age=12}, 456]
[123, BB, 456, AA, Person{name='Tom', age=12}, 456]
9
123
Process finished with exit code 0
```
使用案例②
```java
@Test
public void test2(){
ArrayList list = new ArrayList();
list.add(123);
list.add(456);
list.add("AA");
list.add(new Person("Tom",12));
list.add(456);
//int indexOf(Object obj):返回obj在集合中首次出现的位置。如果不存在，返回-1.
int index = list.indexOf(4567);
System.out.println(index);
//int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置。如果不存在，返回-1.
System.out.println(list.lastIndexOf(456));
//Object remove(int index):移除指定index位置的元素，并返回此元素
Object obj = list.remove(0);
System.out.println(obj);
System.out.println(list);
//Object set(int index, Object ele):设置指定index位置的元素为ele
list.set(1,"CC");
System.out.println(list);
//List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的左闭右开区间的子集合
List subList = list.subList(2, 4);
System.out.println(subList);
System.out.println(list);
}
```
输出结果
```java
-1
4
123
[456, AA, Person{name='Tom', age=12}, 456]
[456, CC, Person{name='Tom', age=12}, 456]
[Person{name='Tom', age=12}, 456]
[456, CC, Person{name='Tom', age=12}, 456]
Process finished with exit code 0
```
使用案例③
```java
@Test
public void test3(){
ArrayList list = new ArrayList();
list.add(123);
list.add(456);
list.add("AA");
//方式一：Iterator迭代器方式
Iterator iterator = list.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
System.out.println("***************");
//方式二：增强for循环
for(Object obj : list){
System.out.println(obj);
}
System.out.println("***************");
//方式三：普通for循环
for(int i = 0;i < list.size();i++){
System.out.println(list.get(i));
}
}
```
输出结果
```java
123
456
AA
***************
123
456
AA
***************
123
456
AA
Process finished with exit code 0
```
**常用方法总结：**
增：add(Object obj)
删：remove(int index) / remove(Object obj)
改：set(int index, Object ele)
查：get(int index)
插：add(int index, Object ele)
长度：size()
遍历：
- ① `Iterator` 迭代器方式
- ② 增强 `for` 循环（foreach）
- ③ 普通的循环
### 拓展
1、ArrayList、LinkedList、Vector 各有优缺点，下面我们来具体分析
相同的
- 三个类都实现了 List 接口，储存数据的特点相同：储存有序的、可重复的
不同之处
- `ArrayList`：
- 作为List接口的主要实现类，线程不安全的，效率高。
- 适用于频繁读取的使用场景，而当数量大时进行插入和删除的操作效率较低，因为 ArrayList 在进行写入、删除等操作时需要向后移动数据。当数据量巨大时，开销也是巨大的。
- 底层使用 `Object[] elementData` 存储
- `LinkedList`：
- 对于频繁的插入、删除操作，使用此类效率比ArrayList高，但是查询效率相对较低，原因LinkedList在查询时要移动指针。
- 底层使用双向链表存储
- `Vector`：
- 作为 `List` 接口的古老实现类；线程安全的，效率低；
- 底层使用 `Object[] elementData` 存储
- Vector 中大量的使用了 synchronized，属于强同步类。因此开销就比 `ArrayList` 要大，访问要慢。
- Vector 每次扩容请求其大小的2倍空间，而ArrayList是1.5倍。
2、区分List中 `remove(int index)` 和 `remove(Object obj)`
```java
@Test
public void testListRemove() {
List list = new ArrayList();
list.add(1);
list.add(2);
list.add(3);
updateList(list);
System.out.println(list);//
}
private void updateList(List list) {
//删除下标为2的对象
list.remove(2);
//删除值为2的对象
list.remove(new Integer(2));
}
```
## 0x04：Set接口
### 概述
- Set接口是 `Collection` 的子接口， set接口没有提供额外的方法。
- Set 集合不允许包含相同的元素，如果试把两个相同的元素加入同一个Set 集合中，则添加操作失败。
- Set 判断两个对象是否相同不是使用 == 运算符，而是根据 `equals()` 方法
总结：Set接口：存储无序的、不可重复的数据
Set接口下有3个子类的实现：
- `HashSet`：
作为Set接口的主要实现类；线程不安全的；可以存储null值
- `LinkedHashSet`：
作为HashSet的子类；遍历其内部数据时，可以按照添加的顺序遍历，对于频繁的遍历操作，LinkedHashSet效率高于HashSet.
- `TreeSet`：
可以按照添加对象的指定属性，进行排序。
下面我们来深入了解一下 `Set` 接口下的这几个子类的基本使用以及其实现原理。
### 实现类：HashSet
`HashSet` 是 `Set` 接口的典型实现，它按 `Hash` 算法来存储集合中的元素，因此具有很好的存取、查找、删除性能，所以作为 `Set` 的主要实现类
`HashSet` 底层也是数组， 初始容量为 `16`， 当如果使用率超过 `0.75`， （16*0.75=12）就会扩大容量为原来的 `2` 倍。例如 `16` 扩容为 `32`， 依次为64,128....等）
`HashSet` 具有以下特点：
- 无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定的。
- 不可重复性：保证添加的元素按照 `equals()` 判断时，不能返回 `true`，即：相同的元素只能添加一个。
- HashSet 不是 “线程安全” 的
- 集合元素可以是 `null`
**HashSet 集合判断两个元素相等的标准**
- 两个对象通过 `hashCode()` 方法比较相等，并且两个对象的 `equals()` 方法返回值也相等。
- 对于存放在 `Set` 容器中的对象， 对应的类一定要重写 `equals()` 和 `hashCode(Objectobj)`方法，以实现对象相等规则。即： “相等的对象必须具有相等的散列码” 。
一个简单的使用案例
```java
@Test
public void test1(){
Set set = new HashSet();
set.add(456);
set.add(123);
set.add(123);
set.add("AA");
set.add("CC");
set.add(new User("Tom",12));
set.add(new User("Tom",12));
set.add(129);
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
```
**向 HashSet 中添加元素的过程**
假设我们向 `HashSet` 中添加元素 `a`,首先调用元素 `a` 所在类的 `hashCode(`) 方法，计算元素`a` 的 “哈希值”，此哈希值接着通过某种算法计算出在 `HashSet` 底层数组中的存放位置（即为：索引位置），接下来判断数组的此位置上是否已经有元素：
- 如果此位置上没有其他元素，则元素a添加成功。（情况1）
- 如果此位置上有其他元素b(或以链表形式存在的多个元素），则比较元素 `a` 与元素 `b` 的`hash` 值：
- 如果hash值不相同，则元素a添加成功。（情况2）
- 如果hash值相同，进而需要调用元素a所在类的 `equals()` 方法：
- `equals()` 返回 `true`,元素a添加失败
- `equals()` 返回 `false`,则元素a添加成功。（情况3）
对于添加成功的 “情况2” 和 “情况3” 而言：元素 `a` 与已经存在指定索引位置上数据以链表的方式存储。但如果是在情况 `3`，在添加新的元素时原有的位置已经存在元素，在 `JDK7` 与 `JDK8` 的储存方式会有些不同
- jdk 7 : 新加入的元素放到数组中，指向原来的元素。
- jdk 8 : 原来的元素在数组中，指向新加入的元素
- 总结：七上八下（新元素相较于旧元素的位置方向）
综上可知，`HashSet` 是数组和链表的结合体，如下图
#### 关于hashCode()与equals()的重写
* 要求1：向Set (主要指：HashSet、LinkedHashSet)中添加的数据，其所在的类一定要重写 `hashCode()` 和 `equals()`
* 要求2：重写的 `hashCode()` 和 `equals()` 尽可能保持一致性：相等的对象必须具有相等的散列码
1、重写 `hashCode()` 方法的基本原则
- 在程序运行时，同一个对象多次调用 hashCode() 方法应该返回相同的值。
- 当两个对象的 equals() 方法比较返回 true 时，这两个对象的 hashCode()方法的返回值也应相等。
- 对象中用作 equals() 方法比较的 Field，都应该用来计算 hashCode 值。
2、重写 `equals()` 方法的基本原则
以自定义的 `Customer` 类为例，何时需要重写 `equals()`？
- 当一个类有自己特有的“逻辑相等”概念,当改写 `equals()` 的时候，总是要改写 `hashCode()`，根据一个类的 `equals` 方法（改写后），两个截然不同的实例有可能在逻辑上是相等的，但是， 根据`Object.hashCode()` 方法，它们仅仅是两个对象。
- 因此，违反了“相等的对象必须具有相等的散列码”。
- 结论：复写equals方法的时候一般都需要同时复写hashCode方法。 通常参与计算hashCode的对象的属性也应该参与到equals()中进行计算。
3、重写的案例
```java
public class User{
private String name;
private int age;
public User() {
}
public User(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
System.out.println("User equals()....");
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
User user = (User) o;
if (age != user.age) return false;
return name != null ? name.equals(user.name) : user.name == null;
}
@Override
public int hashCode() { //return name.hashCode() + age;
int result = name != null ? name.hashCode() : 0;
result = 31 * result + age;
return result;
}
}
```
日常开发中，我们可以使用 `idea` 等开发工具一键生成
按下 `Alt` + `Insert` 键可以一键生成 `equals()` 和 `hashCode()` 的重写方法
#### LinkedHashSet
- LinkedHashSet 作为 `HashSet` 的子类，在添加数据的同时，每个数据还维护了两个引用，记录此数据前一个数据和后一个数据的索引位置。
- LinkedHashSet 根据元素的 `hashCode` 值来决定元素的存储位置，但它同时使用双向链表维护元素的次序，这使得元素看起来是以插入顺序保存的。
优点：对于频繁的遍历操作，`LinkedHashSet` 效率高于 `HashSet`
缺点：`LinkedHashSet` 插入性能略低于 `HashSet`
简单的使用案例
```java
@Test
public void test2(){
Set set = new LinkedHashSet();
set.add(456);
set.add(123);
set.add(123);
set.add("AA");
set.add("CC");
set.add(new User("Tom",12));
set.add(new User("Tom",12));
set.add(129);
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
```
底层结构图
### 实现类：TreeSet
`TreeSet` 储存的对象必须是同一个类型的
两种排序方式：自然排序（实现Comparable接口）、定制排序（Comparator）
- 自然排序中，比较两个对象是否相同的标准为：compareTo()返回0，不再是equals()
- 定制排序中，比较两个对象是否相同的标准为：compare()返回0，不再是equals()
1、自然排序（Comparable）在TreeSet中的使用案例
```java
@Test
public void test1(){
TreeSet set = new TreeSet();
//失败：不能添加不同类的对象
// set.add(123);
// set.add(456);
// set.add(456);
// set.add("AA");
// set.add(new User("Tom",12));
//举例一：
// set.add(34);
// set.add(-34);
// set.add(43);
// set.add(11);
// set.add(8);
//举例二：
set.add(new User("Tom",12));
set.add(new User("Jerry",32));
set.add(new User("Jim",2));
set.add(new User("Mike",65));
set.add(new User("Jack",33));
set.add(new User("Jack",56));
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
```
User类
```java
public class User implements Comparable{
private String name;
private int age;
// ... ...
// 省略构造器和Geter、Seter的代码
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
System.out.println("User equals()....");
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
User user = (User) o;
if (age != user.age) return false;
return name != null ? name.equals(user.name) : user.name == null;
}
@Override
public int hashCode() { //return name.hashCode() + age;
int result = name != null ? name.hashCode() : 0;
result = 31 * result + age;
return result;
}
//按照姓名从大到小排列,年龄从小到大排列
@Override
public int compareTo(Object o) {
if(o instanceof User){
User user = (User)o;
// return -this.name.compareTo(user.name);
int compare = -this.name.compareTo(user.name);
if(compare != 0){
return compare;
}else{
return Integer.compare(this.age,user.age);
}
}else{
throw new RuntimeException("输入的类型不匹配");
}
}
}
```
执行结果
```
User{name='Tom', age=12}
User{name='Mike', age=65}
User{name='Jim', age=2}
User{name='Jerry', age=32}
User{name='Jack', age=33}
User{name='Jack', age=56}
```
2、定制排序（Comparator）在 `TreeSet` 中的使用案例
```java
@Test
public void test2(){
Comparator com = new Comparator() {
//按照年龄从小到大排列
@Override
public int compare(Object o1, Object o2) {
if(o1 instanceof User && o2 instanceof User){
User u1 = (User)o1;
User u2 = (User)o2;
return Integer.compare(u1.getAge(),u2.getAge());
}else{
throw new RuntimeException("输入的数据类型不匹配");
}
}
};
TreeSet set = new TreeSet(com);
set.add(new User("Tom",12));
set.add(new User("Jerry",32));
set.add(new User("Jim",2));
set.add(new User("Mike",65));
set.add(new User("Mary",33));
set.add(new User("Jack",33));
set.add(new User("Jack",56));
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
```
### 拓展
练习1：在List中去除重复的数字值
```java
public static List duplicateList(List list) {
HashSet set = new HashSet();
set.addAll(list);
return new ArrayList(set);
}
@Test
public void test2(){
List list = new ArrayList();
list.add(new Integer(1));
list.add(new Integer(2));
list.add(new Integer(2));
list.add("ddd");
list.add(new Integer(4));
List list2 = duplicateList(list);
for (Object integer : list2) {
System.out.println(integer);
}
}
```
输出结果
```
1
2
4
ddd
```
思路：使用 `HashSet` 实现过滤重复
练习2：解释下面例子的输出结果
```java
@Test
public void test3(){
HashSet set = new HashSet();
Person p1 = new Person(1001,"AA");
Person p2 = new Person(1002,"BB");
set.add(p1);
set.add(p2);
System.out.println(set);
//情况1：
p1.name = "CC";
set.remove(p1);
System.out.println(set);
//情况2：
set.add(new Person(1001,"CC"));
System.out.println(set);
//情况3：
set.add(new Person(1001,"AA"));
System.out.println(set);
}
```
输出结果
```java
[Person{id=1002, name='BB'}, Person{id=1001, name='AA'}]
[Person{id=1002, name='BB'}, Person{id=1001, name='CC'}]
[Person{id=1002, name='BB'}, Person{id=1001, name='CC'}, Person{id=1001, name='CC'}]
[Person{id=1002, name='BB'}, Person{id=1001, name='CC'}, Person{id=1001, name='CC'}, Person{id=1001, name='AA'}]
```
情况1：由于修改了 `p1` 对象的属性值，此时remove方法进行 `hashCode` 时得到的值不一致，所以成功写入该Set集合
情况2：通过 `hashCode` 计算属性值为 `id=1001, name='AA'` 的对象得到的索引位置，该位置上的没有储存任何的值（虽然修将p1的name修改为了 “CC” ，但是他的索引位置没变）所以成功写入。
情况3：通过 `hashCode` 得到的 `new Person(1001,"AA")` 与 p1 的值相同，但此时的 `p1` 对象的name为 “CC”，所以与p1进行 `equals()` 得到的结果为 `false`，所以写入成功。
# 总结
通过本篇笔记的整理，再次巩固了对 Collection 接口下的 List、Set 的各项实现类，例如 `ArrayList` 、`LinkedList`、`HashSet` 的使用方法及其原理有了进一步的认识。
【Java基础】浅谈Collection中List、Set与的实现
