Java Collection接口之： List接口&Set接口

大数据技术AI

Flink/Spark/Hadoop/数仓，数据分析、面试，源码解读等干货学习资料

101篇原创内容

公众号

1、 List 接口

• List集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引。

• List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。

• JDK API中List接口的实现类常用的有：ArrayList、LinkedList和Vector。

1.1 List接口的方法

List除了从Collection集合继承的方法外，List 集合里添加了一些根据索引来操作集合元素的方法

• void add(int index, Object ele)

• boolean addAll(int index, Collection eles)

  扫描二维码关注公众号，回复： 14414592 查看本文章

• Object get(int index)

• int indexOf(Object obj)

• int lastIndexOf(Object obj)

• Object remove(int index)

• Object set(int index, Object ele)

• List subList(int fromIndex, int toIndex)

1.2 List接口的迭代器ListIterator

除了foreach和Iterator迭代器之外，List 额外提供了一个 listIterator() 方法，该方法返回一个 ListIterator 对象， ListIterator 接口继承了 Iterator 接口，提供了专门操作 List 的方法：

• void add()

• void set(Object obj)

• void remove()

• boolean hasPrevious()

• Object previous()

• int previousIndex()

• boolean hasNext()

• Object next()

• int nextIndex()

1.3 List的实现类之一：ArrayList

1、ArrayList概述

1. ArrayList是List 接口的典型实现类、主要实现类

2. 本质上，ArrayList是对象引用的一个”变长”数组

3. ArrayList的JDK1.8之前与之后的实现区别？

• JDK1.7：ArrayList像饿汉式，直接创建一个初始容量为10的数组

• JDK1.8：ArrayList像懒汉式，一开始创建一个长度为0的数组，当添加第一个元素时再创建一个始容量为10的数组

1. Arrays.asList(…) 方法返回的List 集合，既不是ArrayList实例，也不是Vector 实例

2. Arrays.asList(…) 返回值是一个固定长度的List 集合

2、ArrayList 源码分析

//底层创建了长度是10的Object[]数组elementData
ArrayList list = new ArrayList();
//elementData[0] = new Integer(123);
list.add(123);
//如果此次的添加导致底层elementData数组容量不够，则扩容。
list.add(11);

JDK7情况下默认情况下，扩容为原来的容量的1.5倍，同时需要将原有数组中的数据复制到新的数组中。

小结：建议开发中使用带参的构造器：ArrayList list = new ArrayList(int capacity)

 public class ArrayList<E> extends AbstractList<E>
         implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{

     private transient Object[] elementData;

     /**
      * Constructs an empty list with an initial capacity of ten.
      */
     public ArrayList() {
         this(10);
     }

     public ArrayList(int initialCapacity) {
         super();
         if (initialCapacity < 0)
             throw new IllegalArgumentException("Illegal Capacity: "+
                                                initialCapacity);
         // 创建集合的时候，就创建了长度为10的集合                                       
         this.elementData = new Object[initialCapacity];
     }

     public boolean add(E e) {
         ensureCapacityInternal(size + 1);  // Increments modCount!!
         elementData[size++] = e;
         return true;
     }

     private void ensureCapacityInternal(int minCapacity) {
         modCount++;
         // overflow-conscious code
         if (minCapacity - elementData.length > 0)
             grow(minCapacity);
     }

     private void grow(int minCapacity) {
         // overflow-conscious code
         int oldCapacity = elementData.length;
         int newCapacity = oldCapacity + (oldCapacity >> 1);
         if (newCapacity - minCapacity < 0)
             newCapacity = minCapacity;
         if (newCapacity - MAX_ARRAY_SIZE > 0)
             newCapacity = hugeCapacity(minCapacity);
         // minCapacity is usually close to size, so this is a win:
         elementData = Arrays.copyOf(elementData, newCapacity);
     }

 }

创建集合的时候，就创建了长度为10的集合

Constructs an empty list with an initial capacity of ten

JDK8中ArrayList的变化

 //底层Object[] elementData初始化为{}.并没有创建长度为10的数组
 ArrayList list = new ArrayList();
 //第一次调用add()时，底层才创建了长度10的数组，并将数据123添加到elementData[0]
 list.add(123);

底层Object[] elementData初始化为{}.并没有创建长度为10的数组

第一次调用add()时，底层才创建了长度10的数组，并将数据123添加到elementData[0]

后续的添加和扩容操作与jdk 7 无异。

小结：jdk7中的ArrayList的对象的创建类似于单例的饿汉式，而jdk8中的ArrayList的对象的创建类似于单例的懒汉式，延迟了数组的创建，节省内存。

 public class ArrayList<E> extends AbstractList<E>
         implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
     /**
     * Default initial capacity.
     */
     private static final int DEFAULT_CAPACITY = 10;

     private static final Object[] EMPTY_ELEMENTDATA = {};

     private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

     transient Object[] elementData; // non-private to simplify nested class access


     public ArrayList(int initialCapacity) {
         if (initialCapacity > 0) {
             this.elementData = new Object[initialCapacity];
         } else if (initialCapacity == 0) {
             this.elementData = EMPTY_ELEMENTDATA;
         } else {
             throw new IllegalArgumentException("Illegal Capacity: "+
                                                initialCapacity);
         }
     }

     public ArrayList() {
         // 初始化一个空集合
         this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
     }    

     public boolean add(E e) {
         ensureCapacityInternal(size + 1);  // Increments modCount!!
         elementData[size++] = e;
         return true;
     }

     private void ensureCapacityInternal(int minCapacity) {
         // 添加第一个元素时，进入if判断
         // minCapacity=1, DEFAULT_CAPACITY=10,取最大值10
         if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
             minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
         }
         // 不是第一次添加元素
         ensureExplicitCapacity(minCapacity);
     }

     private void ensureExplicitCapacity(int minCapacity) {
         modCount++;
         // overflow-conscious code
         if (minCapacity - elementData.length > 0)
             grow(minCapacity);
     }  

     private void grow(int minCapacity) {
         // overflow-conscious code
         int oldCapacity = elementData.length;
         // 新容量是原来的，1.5倍
         // 第一次，oldCapacity =0
         int newCapacity = oldCapacity + (oldCapacity >> 1);
         if (newCapacity - minCapacity < 0)
             newCapacity = minCapacity;
         if (newCapacity - MAX_ARRAY_SIZE > 0)
             newCapacity = hugeCapacity(minCapacity);
         // minCapacity is usually close to size, so this is a win:
         elementData = Arrays.copyOf(elementData, newCapacity);
     } 

 }

1.4 List的实现类之二：Vector

• Vector 是一个古老的集合，JDK1.0就有了。大多数操作与ArrayList相同，区别之处在于Vector是线程安全的。

• 在各种list中，最好把ArrayList作为缺省选择。

• 当插入、删除频繁时，使用LinkedList；

• Vector总是比ArrayList慢，所以尽量避免使用。

• jdk7和jdk8中通过Vector()构造器创建对象时，底层都创建了长度为10的数组。

• 在扩容方面，默认扩容为原来的数组长度的2倍。

1.5 List的实现类之三：LinkedList

LinkedList：双向链表，除了保存数据，还定义了两个变量：

1. prev变量记录前一个元素的位置

2. next变量记录下一个元素的位置

对于频繁的插入或删除元素的操作，建议使用LinkedList类，效率较高

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

问ArrayList/LinkedList/Vector的异同？谈谈你的理解？ArrayList底层是什么？扩容机制？Vector和ArrayList的最大区别?

ArrayList：作为List接口的主要实现类；线程不安全的，效率高；底层使用Object[] elementData存储

LinkedList：对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储

Vector：作为List接口的古老实现类；线程安全的，效率低；底层使用Object[] elementData存储

ArrayList和LinkedList

• 二者都线程不安全，相对线程安全的Vector，执行效率高。

• ArrayList是实现了基于动态数组的数据结构

• LinkedList基于链表的数据结构。

• 对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。

• 对于操作add(特指插入)和remove，LinkedList比较占优势，因为ArrayList要移动数据。

ArrayList和Vector

• Vector和ArrayList几乎是完全相同的

• 唯一的区别在于Vector是同步类(synchronized)，属于强同步类。因此开销就比ArrayList要大，访问要慢。

• 正常情况下,大多数的Java程序员使用ArrayList而不是Vector,因为同步完全可以由程序员自己来控制。

• Vector每次扩容请求其大小的2倍空间，而ArrayList是1.5倍。

• Vector还有一个子类Stack。

2、Set 接口

• Set接口是Collection的子接口，set接口没有提供额外的方法。

• Set 集合不允许包含相同的元素，如果试把两个相同的元素加入同一个 Set 集合中，则添加操作失败。

• Set 判断两个对象是否相同不是使用 == 运算符，而是根据 equals 方法。因此存放到Set集合中的元素一定要注意equals方法的重写。

• Set的常用实现类有：HashSet、TreeSet、LinkedHashSet。

2.1 Set实现类之一：HashSet

• 特点

1. HashSet是Set 接口的典型实现，大多数时候使用Set 集合时都使用这个实现类。

2. HashSet按Hash 算法来存储集合中的元素，因此具有很好的存取、查找、删除性能。

3. HashSet具有以下特点：

4. 不能保证元素的排列顺序

5. HashSet不是线程安全的

6. 集合元素可以是null

7. HashSet 集合判断两个元素相等的标准：两个对象通过hashCode() 方法比较相等，并且两个对象的equals() 方法返回值也相等。

8. 对于存放在Set容器中的对象，对应的类一定要重写equals()和hashCode(Object obj)方法，以实现对象相等规则。即：“相等的对象必须具有相等的散列码”

9. 底层也是数组，初始容量为16，当如果使用率超过0.75，（16*0.75=12）就会扩大容量为原来的2倍。（16扩容为32，依次为64,128…等）

• 重写hashCode() 方法的基本原则

1. 在程序运行时，同一个对象多次调用hashCode() 方法应该返回相同的值。

2. 当两个对象的equals() 方法比较返回true 时，这两个对象的hashCode() 方法的返回值也应相等

3. 对象中用作equals() 方法比较的Field，都应该用来计算hashCode 值。

• 重写equals() 方法的基本原则

以自定义的Customer类为例，何时需要重写equals()？

1. 当一个类有自己特有的“逻辑相等”概念,当改写equals()的时候，总是要改写hashCode()，根据一个类的equals方法（改写后），两个截然不同的实例有可能在逻辑上是相等的，但是，根据Object.hashCode()方法，它们仅仅是两个对象。

2. 因此，违反了“相等的对象必须具有相等的散列码”。

3. 结论：复写equals方法的时候一般都需要同时复写hashCode方法。通常参与计算hashCode的对象的属性也应该参与到equals()中进行计算。

• 源码分析：

1. Set：存储无序的、不可重复的数据

2. 无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定的。

3. 不可重复性：保证添加的元素按照equals()判断时，不能返回true.即：相同的元素只能添加一个。

4. 添加元素的过程：以HashSet为例：

我们向HashSet中添加元素a,首先调用元素a所在类的hashCode()方法，计算元素a的哈希值，

此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置（即为：索引位置），判断

数组此位置上是否已经有元素：

1. 如果此位置上没有其他元素，则元素a添加成功。—> 情况1

2. 如果此位置上有其他元素b(或以链表形式存在的多个元素），则

   比较元素a与元素b的hash值

3. equals()返回true,元素a添加失败

4. equals()返回false,则元素a添加成功。—> 情况2

5. 如果hash值不相同，则元素a添加成功。—> 情况2

6. 如果hash值相同，进而需要调用元素a所在类的

   equals()方法进行比较

   ：

7. 对于添加成功的情况2和情况3而言：元素a 与已经存在指定索引位置上数据以链表的方式存储。

jdk 7 :元素a放到数组中，指向原来的元素。

jdk 8 :原来的元素在数组中，指向元素a

HashSet底层：数组+链表的结构。

11.5.2 Set实现类之二：LinkedHashSet

1. LinkedHashSet是HashSet的子类

2. LinkedHashSet根据元素的hashCode值来决定元素的存储位置，但它同时使用双向链表维护元素的次序，这使得元素看起来是以插入顺序保存的。

3. LinkedHashSet插入性能略低于HashSet，但在迭代访问Set 里的全部元素时有很好的性能

4. LinkedHashSet不允许集合元素重复。

11.5.3 Set实现类之三：TreeSet

1. TreeSet是SortedSet接口的实现类

2. TreeSet可以确保集合元素处于排序状态。

3. TreeSet底层使用红黑树结构存储数据

4. TreeSet两种排序方法：自然排序和定制排序。

5. 默认情况下，TreeSet采用自然排序。TreeSet的自然排序是根据集合元素的大小，从小到大

6. 特点：有序，查询速度比List快

• 自然排序：

1. 自然排序：TreeSet会调用集合元素的compareTo(Object obj) 方法来比较元素之间的大小关系，然后将集合元素按升序(默认情况)排列

2. 如果试图把一个对象添加到TreeSet时，则该对象的类必须实现Comparable 接口。

3. 实现Comparable 的类必须实现compareTo(Object obj) 方法，两个对象即通过compareTo(Object obj) 方法的返回值来比较大小。

Comparable 的典型实现：

1. BigDecimal、BigInteger 以及所有的数值型对应的包装类：按它们对应的数值大小进行比较

2. Character：按字符的unicode值来进行比较

3. Boolean：true 对应的包装类实例大于false 对应的包装类实例

4. String：按字符串中字符的unicode 值进行比较

5. Date、Time：后边的时间、日期比前面的时间、日期大

 public class User implements Comparable{
     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;
     }

     //按照姓名从大到小排列,年龄从小到大排列
     @Override
     public int compareTo(Object o) {
         if(o instanceof User){
             User user = (User)o;
             int compare = -this.name.compareTo(user.name);
             if(compare != 0){
                 return compare;
             }else{
                 return Integer.compare(this.age,user.age);
             }
         }else{
             throw new RuntimeException("输入的类型不匹配");
         }

     }
 }

• 定制排序：

1. TreeSet的自然排序要求元素所属的类实现Comparable接口，如果元素所属的类没有实现Comparable接口，或不希望按照升序(默认情况)的方式排列元素或希望按照其它属性大小进行排序，则考虑使用定制排序。

2. 定制排序，通过Comparator接口来实现。需要重写compare(T o1,T o2)方法。

3. 利用int compare(T o1,T o2)方法，比较o1和o2的大小：如果方法返回正整数，则表示o1大于o2；如果返回0，表示相等；返回负整数，表示o1小于o2。

4. 要实现定制排序，需要将实现Comparator接口的实例作为形参传递给TreeSet的构造器。

5. 此时，仍然只能向TreeSet中添加类型相同的对象。否则发生ClassCastException异常。

6. 使用定制排序判断两个元素相等的标准是：通过Comparator比较两个元素返回了0

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

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

为什么用复写hashCode方法，有31这个数字？

1. 选择系数的时候要选择尽量大的系数。因为如果计算出来的hash地址越大，所谓的“冲突”就越少，查找起来效率也会提高。（减少冲突）

2. 并且31只占用5bits,相乘造成数据溢出的概率较小。

3. 31可以由i*31== (i<<5)-1来表示,现在很多虚拟机里面都有做相关优化。（提高算法效率）

4. 31是一个素数，素数作用就是如果我用一个数字来乘以这个素数，那么最终出来的结果只能被素数本身和被乘数还有1来整除！(减少冲突)