概述

通过该笔记的整理，对 JAVA 的 Collection（集合）的基本使用和一些常见的使用场景、底层源码等知识点进行巩固，以达到 “温故知新” 的目的。

目录

• 概述
• 目录
• 主要内容
  • 0x01：集合框架的概述
  • 0x02：Collection接口中的常用方法
  • 0x02：Iterator 迭代器
    • 概述
    • 遍历
      • 使用foreach进行遍历
    • 移除
  • 0x03：List接口
    • 概述
    • 实现类：ArrayList
    • 实现类：LinkedList
    • 实现类：Vector
    • 常用的方法及使用
    • 拓展
  • 0x04：Set接口
    • 概述
    • 实现类：HashSet
      • 关于hashCode()与equals()的重写
      • LinkedHashSet
    • 实现类：TreeSet
    • 拓展
• 总结

主要内容

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()：

  返回迭代器对象，用于集合遍历

部分用例代码如下

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（迭代器)遍历集合

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 对象，则必须有一个被迭代的集合。

错误的示范：

//错误方式一：
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还可以用来遍历数组。

编辑集合

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);
}

遍历数组

int[] arr = new int[]{1,2,3,4,5,6};
//for(数组元素的类型 局部变量 : 数组对象)
for(int i : arr){
    System.out.println(i);
}

练习题：使用 foreach 遍历的数组，重新赋值不会影响原数组的值，如下

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() 方法

//删除集合中"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

ArrayList list = new ArrayList();

底层创建了长度是 10 的 Object[] 数组elementData 如下图

接着往list内添加数据

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 变量记录下一个元素的位置

源码如下

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

实现类：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位置的子集合

使用案例 ①

@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));
}

输出结果

[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

使用案例②

@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);
}

输出结果

-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

使用案例③

@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));
    }
}

输出结果

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)

@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)方法，以实现对象相等规则。即： “相等的对象必须具有相等的散列码” 。

一个简单的使用案例

@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、重写的案例

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

简单的使用案例

@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中的使用案例

@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类

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 中的使用案例

@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中去除重复的数字值

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：解释下面例子的输出结果

@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);

}

输出结果

[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 的使用方法及其原理有了进一步的认识。