【JAVA高级&集合框架】浅谈Collection中List、Set与的实现

【JAVA高级&集合框架】浅谈Collection中List、Set与的实现

概述

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

目录

主要内容

0x01:集合框架的概述

面向对象语言对事物的体现都是以对象的形式,为了方便对多个对象的操作,就要对对象进行存储。另一方面,使用 Array 存储对象方面具有一些弊端,而Java 集合就像一种容器,可以动态地把多个对象的引用放入容器中。

  • 数组在存储多个数据方面的特点:
    • 一旦初始化以后,其长度就确定了。
    • 数组一旦定义好,其元素的类型也就确定了。我们也就只能操作指定类型的数据了。
  • 数组在存储多个数据方面的缺点:
    • 一旦初始化以后,其长度就不可修改。
    • 数组中提供的方法非常有限,对于添加、删除、插入数据等操作,非常不便,同时效率不高。
    • 获取数组中实际元素的个数的需求,数组没有现成的属性或方法可用
    • 数组存储数据的特点:有序、可重复。对于无序、不可重复的需求,不能满足。

使用集合可以解决上述数组在储存多个数据时的缺点。

Java 集合类可以用于存储数量不等的多个对象,还可用于保存具有映射关系的关联数组。

Java 集合可分为 CollectionMap 两种体系

  • Collection接口: 单列数据, 定义了存取一组对象的方法的集合
    • List: 元素有序、可重复的集合
      • ArrayList、LinkedList、Vector
    • Set: 元素无序、不可重复的集合
      • HashSet、LinkedHashSet、TreeSet
  • Map接口: 双列集合,可以储存双列数据,保存具有映射关系 “key-value” 的集合
    • HashMap、LinkedHashMap、TreeMap、Hashtable、Properties

Collection接口继承树

Map接口继承树

0x02:Collection接口中的常用方法

Collection 接口是 ListSetQueue 接口的父接口,该接口里定义的方法既可用于操作 Set 集合,也可用于操作 ListQueue 集合。

JDK 不提供此接口的任何直接实现,而是提供更具体的子接口 (如: SetList)实现。

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 APIList 接口的实现类常用的有: ArrayList、 LinkedList和Vector。

实现类:ArrayList

JDK7JDK8 的情况会有些不同,我们继续具体的分析

JDK7 的情况下:

初始化 ArrayList

ArrayList list = new ArrayList();

底层创建了长度是 10Object[] 数组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 类型的 firstlast,用于记录首末元素。同时,定义内部类 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 是线程安全的。

jdk7jdk8中通过 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

HashSetSet 接口的典型实现,它按 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 与元素 bhash 值:
    • 如果hash值不相同,则元素a添加成功。(情况2)
    • 如果hash值相同,进而需要调用元素a所在类的 equals() 方法:
      • equals() 返回 true,元素a添加失败
      • equals() 返回 false,则元素a添加成功。(情况3)

对于添加成功的 “情况2” 和 “情况3” 而言:元素 a 与已经存在指定索引位置上数据以链表的方式存储。但如果是在情况 3,在添加新的元素时原有的位置已经存在元素,在 JDK7JDK8 的储存方式会有些不同

  • 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 的各项实现类,例如 ArrayListLinkedListHashSet 的使用方法及其原理有了进一步的认识。

Copyright: 采用 知识共享署名4.0 国际许可协议进行许可

Links: https://codeyee.com/archives/java-collection.html