集合（一） ArrayList 详解

往期推荐

• Java基础知识
• Java并发编程
• JVM

1、ArrayList简介

1.1 ArrayList概述

ArrayList继承于 AbstractList ，实现了 List, RandomAccess, Cloneable, java.io.Serializable 这些接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现，支持随机访问。

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

  }

• 每个ArrayList都有一个容量(capacity)，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。

• 为追求效率，ArrayList没有实现同步(synchronized)，如果需要多个线程并发访问，用户可以手动同步，也可使用Vector替代。

• RandomAccess 是一个标志接口，表明实现这个这个接口的 List 集合是支持快速随机访问的。在 ArrayList 中，我们即可以通过元素的序号快速获取元素对象，这就是快速随机访问。

• ArrayList 实现了 Cloneable 接口 ，即覆盖了函数clone()，能被克隆。

• ArrayList 实现了 java.io.Serializable接口，这意味着ArrayList支持序列化，能通过序列化去传输。

1.2 ArrayList类结构

package java.util;

import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.function.UnaryOperator;


public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
    private static final long serialVersionUID = 8683452581122892189L;

    /**
     * 默认初始容量大小
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * 空数组（用于空实例）。
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

     //用于默认大小空实例的共享空数组实例。
      //我们把它从EMPTY_ELEMENTDATA数组中区分出来，以知道在添加第一个元素时容量需要增加多少。
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    /**
     * 保存ArrayList数据的数组
     */
    transient Object[] elementData; // non-private to simplify nested class access

    /**
     * ArrayList 所包含的元素个数
     */
    private int size;
    
    /** 
    * ArrayList所能存储元素的最大容量
    */ private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    /**
     * 修改这个ArrayList实例的容量是列表的当前大小。 应用程序可以使用此操作来最小化ArrayList实例的存储。
     */
    public void trimToSize() {
        modCount++;
        if (size < elementData.length) {
            elementData = (size == 0)
              ? EMPTY_ELEMENTDATA
              : Arrays.copyOf(elementData, size);
        }
    }
}

1.3 ArrayList构造方法

1.3.1 无参构造方法

    /**
     *默认无参构造函数
     *DEFAULTCAPACITY_EMPTY_ELEMENTDATA 为0.初始化为10，也就是说初始其实是空数组 当添加第一个元素的时候数组容量才变成10
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

使用DEFAULTCAPACITY_EMPTY_ELEMENTDATA空数组赋值给elementData。

1.3.2 带初始容量的构造方法

/**
* 带初始容量参数的构造函数（用户可以在创建ArrayList对象时自己指定集合的初始大小）
*/
public ArrayList(int initialCapacity) {
    //如果初始容量大于10
    if (initialCapacity > 0) {
        //初始化一个大小为initialCapacity的数组赋值给数组elementData
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        //如果初始容量等于0
        //则将前面ArrayList定义的类属性EMPTY_ELEMENTDATA空数组赋值给数组elementData
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        //如果初始化容量小于0，则抛出IllegalArgumentException异常
        throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);
    }
}

1.3.3 带集合参数的构造方法

//构造一个包含指定集合的ArrayList
public ArrayList(Collection<? extends E> c) {
    //利用toArray()方法将集合c转换为数组，并将转换后的数组赋值给数组a
    Object[] a = c.toArray();
    //如果数组中的元素个数不等于0
    if ((size = a.length) != 0) {
        //如果集合c的类型为ArrayList
        if (c.getClass() == ArrayList.class) {
            //则将集合c转化后的数组a赋值给数组elementData
            elementData = a;
        } else {
            //否则，复制数组a并将复制后新数组赋值给elementDate数组
            elementData = Arrays.copyOf(a, size, Object[].class);
        }
    } else {
        //数组中元素个数为0，则将EMPTY_ELEMENTDATA(空数组)赋值给elementDate
        elementData = EMPTY_ELEMENTDATA;
    }
}

1.4 ArrayList常用方法

• boolean add(E e) 将指定的元素追加到此列表的末尾。

• void add(int index, E element) 在此列表中的指定位置插入指定的元素。

• E get(int index) 返回此列表中指定位置的元素。

• boolean contains(Object o) 如果此列表包含指定的元素，则返回 true 。

• int indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。

• boolean isEmpty() 如果此列表不包含元素，则返回 true 。

• E set(int index, E element) 用指定的元素替换此列表中指定位置的元素。

• int size() 返回此列表中的元素数。

• boolean remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）。

• E remove(int index) 删除该列表中指定位置的元素。

• boolean addAll(Collection<? extends E> c) 批量将另一个集合c中的元素添加到ArrayList集合的末尾。

• boolean addAll(int index, Collection<? extends E> c) 将另一个集合c中的所有元素插入插入到指定位置index后。

• void clear() 从列表中删除所有元素。

• Iterator<E> iterator() 以正确的顺序返回该列表中的元素的迭代器。

• int lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。

• ListIterator<E> listIterator() 返回列表中的列表迭代器（按适当的顺序）。

• ListIterator<E> listIterator(int index) 从列表中的指定位置开始，返回列表中的元素（按正确顺序）的列表迭代器。

• boolean removeAll(Collection<?> c) 用于删除ArrayList与另一个另一个集合c的交集部分的元素。

• boolean removeIf(Predicate<? super E> filter) 删除满足给定谓词的此集合的所有元素。

• protected void removeRange(int fromIndex, int toIndex) 从这个列表中删除所有索引在 fromIndex （含）和 toIndex之间的元素。

• void replaceAll(UnaryOperator<E> operator) 将该列表的每个元素替换为将该运算符应用于该元素的结果。

• boolean retainAll(Collection<?> c) 仅保留此列表中包含在指定集合中的元素。

• void sort(Comparator<? super E> c) 使用提供的Comparator对此列表中的元素进行比较并排序。

1.5 ArrayList的优缺点

• ArrayList的优点如下：

  1. ArrayList 底层以数组实现，允许对元素进行快速随机访问。ArrayList 实现了RandomAccess 接口，因此查找的时候非常快。
  2. ArrayList 在顺序添加一个元素的时候非常方便，非顺序添加就不合适。

• ArrayList 的缺点如下：

  1. 当从 ArrayList 的中间位置插入或者删除元素时，需要对数组进行复制、移动、代价比较高。因此，它适合随机查找和遍历，不适合插入和删除。
  2. 底层以数组实现则缺点是每个元素之间不能有间隔，当数组大小不满足时需要扩容，就要原数组中的元素复制到新的存储空间中，比较耗费性能。

1.6 Arraylist 和 Vector 的区别?

1. ArrayList 是 List 的主要实现类，底层使用 Object[ ]存储，适用于频繁的查找工作，线程不安全 ；
2. Vector 是 List 的古老实现类，底层使用 Object[ ]存储，线程安全的。

1.7 Arraylist 与 LinkedList 区别?

1. 是否保证线程安全：  ArrayList 和 LinkedList 都是不同步的，也就是不保证线程安全；

2. 底层数据结构：  Arraylist 底层使用的是 Object 数组；LinkedList 底层使用的是 双向链表 数据结构（JDK1.6 之前为循环链表，JDK1.7 取消了循环。注意双向链表和双向循环链表的区别，下面有介绍到！）

3. 插入和删除是否受元素位置的影响：

   ① ArrayList 采用数组存储，所以插入和删除元素的时间复杂度受元素位置的影响。  比如：执行add(E e)方法的时候， ArrayList 会默认在将指定的元素追加到此列表的末尾，这种情况时间复杂度就是 O(1)。但是如果要在指定位置 i 插入和删除元素的话（add(int index, E element)）时间复杂度就为 O(n-i)。因为在进行上述操作的时候集合中第 i 和第 i 个元素之后的(n-i)个元素都要执行向后位/向前移一位的操作。

   ② LinkedList 采用链表存储，所以对于add(E e)方法的插入，删除元素时间复杂度不受元素位置的影响，近似 O(1)，如果是要在指定位置i插入和删除元素的话（(add(int index, E element)） 时间复杂度近似为o(n))因为需要先移动到指定位置再插入。

4. 是否支持快速随机访问：  LinkedList 不支持高效的随机元素访问，而 ArrayList 支持。快速随机访问就是通过元素的序号快速获取元素对象(对应于get(int index)方法)。

5. 内存空间占用：  ArrayList 的空 间浪费主要体现在在 list 列表的结尾会预留一定的容量空间，而 LinkedList 的空间花费则体现在它的每一个元素都需要消耗比 ArrayList 更多的空间（因为要存放直接后继和直接前驱以及数据）。

2、ArrayList扩容机制分析

2.1 先来看 add() 方法

这里以无参构造函数创建的 ArrayList 为例分析

    /**
     * 将指定的元素追加到此列表的末尾。
     */
    public boolean add(E e) {
   //添加元素之前，先调用ensureCapacityInternal方法
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //这里看到ArrayList添加元素的实质就相当于为数组赋值
        elementData[size++] = e;
        return true;
    }

注意 ：JDK11 移除了 ensureCapacityInternal() 和 ensureExplicitCapacity() 方法。

2.2 再来看看 ensureCapacityInternal() 方法

（JDK7）可以看到 add 方法 首先调用了ensureCapacityInternal(size + 1)

 /**
     * 如有必要，增加此ArrayList实例的容量，以确保它至少能容纳元素的数量
     * @param   minCapacity   所需的最小容量
     */
    public void ensureCapacity(int minCapacity) {
        //如果是true，minExpand的值为0，如果是false,minExpand的值为10
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
            // any size if not default element table
            ? 0
            // larger than default for default empty table. It's already
            // supposed to be at default size.
            : DEFAULT_CAPACITY;
        //如果最小容量大于已有的最大容量
        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);
        }
    }
    
       //得到最小扩容量
    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
              // 获取默认的容量和传入参数的较大值
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

当 要 add 进第 1 个元素时，minCapacity 为 1，在 Math.max()方法比较后，minCapacity 为 10。

2.3 接着看ensureExplicitCapacity() 方法

  //判断是否需要扩容
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            //调用grow方法进行扩容，调用此方法代表已经开始扩容了
            grow(minCapacity);
    }

• 当我们要 add 进第 1 个元素到 ArrayList 时，elementData.length 为 0 （因为还是一个空的 list），因为执行了 ensureCapacityInternal() 方法 ，所以 minCapacity 此时为 10。此时，minCapacity - elementData.length > 0成立，所以会进入 grow(minCapacity) 方法。

• 当 add 第 2 个元素时，minCapacity 为 2，此时 elementData.length(容量)在添加第一个元素后扩容成 10 了。此时，minCapacity - elementData.length > 0 不成立，所以不会进入 （执行）grow(minCapacity) 方法。

• 添加第 3、4 ··· 到第 10 个元素时，依然不会执行 grow() 方法，数组容量都为 10。

• 直到添加第 11 个元素，minCapacity(为 11)比 elementData.length（为 10）要大。进入 grow() 方法进行扩容。

2.4 下一步看grow() 方法

    /**
     * 要分配的最大数组大小
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    /**
     * ArrayList扩容的核心方法。
     */
    private void grow(int minCapacity) {
        // oldCapacity为旧容量，newCapacity为新容量
        int oldCapacity = elementData.length;
        //将oldCapacity 右移一位，其效果相当于oldCapacity /2，
        //我们知道位运算的速度远远快于整除运算，整句运算式的结果就是将新容量更新为旧容量的1.5倍，
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //然后检查新容量是否大于最小需要容量，若还是小于最小需要容量，那么就把最小需要容量当作数组的新容量，
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
       // 如果新容量大于 MAX_ARRAY_SIZE,进入(执行) `hugeCapacity()` 方法来比较 minCapacity 和 MAX_ARRAY_SIZE，
       //如果minCapacity大于最大容量，则新容量则为`Integer.MAX_VALUE`，否则，新容量大小则为 MAX_ARRAY_SIZE 即为 `Integer.MAX_VALUE - 8`。
        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);
    }

int newCapacity = oldCapacity + (oldCapacity >> 1),所以 ArrayList 每次扩容之后容量都会变为原来的 1.5 倍左右（oldCapacity 为偶数就是 1.5 倍，否则是 1.5 倍左右）！

• 当 add 第 1 个元素时，oldCapacity 为 0，经比较后第一个 if 判断成立，newCapacity = minCapacity(为 10)。但是第二个 if 判断不会成立，即 newCapacity 不比 MAX_ARRAY_SIZE 大，则不会进入 hugeCapacity 方法。数组容量为 10，add 方法中 return true,size 增为 1。
• 当 add 第 11 个元素进入 grow 方法时，newCapacity 为 15，比 minCapacity（为 11）大，第一个 if 判断不成立。新容量没有大于数组最大 size，不会进入 hugeCapacity 方法。数组容量扩为 15，add 方法中 return true,size 增为 11。
• 以此类推······ 如果新的容量newCapacity大于MAX_ARRAY_SIZE，就需要通过hugeCapacity方法再次计算新的容量newCapacity的大小。确定了新的容量newCapacity后，Arrays.copyOf()方法将旧数组中的元素拷贝到新的数组中，返回新容量的数组。

2.5 最后看 hugeCapacity() 方法

从上面 grow() 方法源码我们知道： 如果新容量大于 MAX_ARRAY_SIZE,进入(执行) hugeCapacity() 方法来比较 minCapacity 和 MAX_ARRAY_SIZE，如果 minCapacity 大于最大容量，则新容量则为Integer.MAX_VALUE，否则，新容量大小则为 MAX_ARRAY_SIZE 即为 Integer.MAX_VALUE - 8。

    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        //对minCapacity和MAX_ARRAY_SIZE进行比较
        //若minCapacity大，将Integer.MAX_VALUE作为新数组的大小
        //若MAX_ARRAY_SIZE大，将MAX_ARRAY_SIZE作为新数组的大小
        //MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

以上就是对ArrayList扩容机制的详细描述