【Java基础-集合篇】-ArrayList及其扩容机制

Java基础集合篇-ArrayList

List接口下有三个实现类：ArrayList、LinkedList和Vector

---

ArrayList

ArrayList简介

ArrayList继承于AbstractList，实现了List，RandomAccess，Cloneable，java.io.Serializable这些接口。

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

• RandomAccess是一个标志接口，表明实现这个接口的List集合是支持快速随机访问的。在ArrayList中，我们即可以通过元素的序号快速获取元素对象，这就是快速随机访问。
• ArrayList实现了Cloneable接口，即覆盖了函数clone()，能被克隆。
• ArrayList实现了java.io.Serializable接口，这意味着ArrayList支持序列化，能通过序列化去传输。

---

ArrayList扩容机制分析

1.ArrayList的构造函数

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


private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

/**
     *默认构造函数，使用初始容量10构造一个空列表(无参数构造)
     */
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

/**
     * 带初始容量参数的构造函数。（用户自己指定容量）
     */
public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {//初始容量大于0
        //创建initialCapacity大小的数组
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {//初始容量等于0
        //创建空数组
        this.elementData = EMPTY_ELEMENTDATA;
    } else {//初始容量小于0，抛出异常
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    }
}


/**
    *构造包含指定collection元素的列表，这些元素利用该集合的迭代器按顺序返回
    *如果指定的集合为null，throws NullPointerException。
    */
public ArrayList(Collection<? extends E> c) {
    elementData = c.toArray();
    if ((size = elementData.length) != 0) {
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        // replace with empty array.
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

以无参数构造方法创建ArrayList时，实际上初始化赋值给elementData的是一个空数组。当其添加第一个元素时，数组容量扩为DEFAULT_CAPACITY=10.

2.add()方法

add方法会首先调用ensureCapacityInternal(int minCapacity)方法。这个方法的作用是判断当前容量是否能容纳下minCapacity，如果不能则扩容。然后再将新元素e添加入elementData数组中。

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

3、ensureCapacityInternal(int minCapacity)的代码

在ensureCapacityInternal()的实现中（下面代码版本是jdk8）。

1、调用calculateCapacity(elementData, minCapacity)。该方法的作用是判断如果elementData==DEFAULTCAPACITY_EMPTY_ELEMENTDATA，那么如果minCapacity<10，那么minCapacity就是10，否则minCapacity不变。得到最终的minCapacity。

2、然后调用ensureExplicitCapacity(int minCapacity)。该方法的作用是判断minCapacity-elementData.length是否大于0，如果大于0，则调用grow()函数扩容。

具体而言，当add第一个元素时，minCapacity-elementData.length=10，因此需要调用grow(10)，将ArrayList扩容至10.当添加2,3…10个元素时，容量足够，无需扩容。而add第11个元素时，容量不足，需要再次调用grow()扩容。

private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

private static int calculateCapacity(Object[] elementData, int minCapacity) {
    // minCapacity-最小容量，elementDat==DEFAULTCAPACITY_EMPTY_ELEMENTDATA
    // 则minCapacity的最小值为10
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // overflow-conscious code
    // 如果最小容量大于当前elementData的大小，
    if (minCapacity - elementData.length > 0)
        // 调用grow方法进行扩容，调用此方法代表已经开始扩容了
        grow(minCapacity);
}

4、grow()方法

以下代码版本是jdk8。

每次扩容，新容量newCapacity是旧容量的oldCapacity1.5倍。如果新容量还是小于minCapacity，则让newCapacity=minCapacity。

具体而言：

1. 当add第1个元素，newCapacity=oldCapacity=0，而minCapacity是10.因此，newCapacity=10.
2. 当add第11个元素，newCapacity为15，比minCapacity（为11）大。因此newCapacity就是15.

hugeCapacity()方法：

如果newCapacity大于MAX_ARRAY_SIZE，进入hugeCapacity()方法比较minCapacity和MAX_ARRAY_SIZE，如果minCapacity大于最大容量，则新容量为Integer.MAX_VALUE,否则，新容量为MAX_ARRAY_SIZE。

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

/**
     * Increases the capacity to ensure that it can hold at least the
     * number of elements specified by the minimum capacity argument.
     *
     * @param minCapacity the desired minimum capacity
     */
/**
     * ArrayList扩容的核心方法
     * @param minCapacity
     */
private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    // 新容量为旧容量的1.5倍
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    // 检查新容量是否大于最小需要容量，若还是小于最小需要容量
    // 那么就把最小容量当作数组的新容量
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    // 再检查新容量是否超出了ArrayList定义的最大容量
    // 若超出了，则调用hugeCapacity()来比较minCapacity和MAX_ARRAY_SIZE
    // 如果minCapicity大于MAX_ARRAY_SIZE，则新容量为Integer.MAX_VALUE,否则，新容量大小为MAX_ARRAY_SIZE
    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);
}

// 比较minCapacity 和 MAX_ARRAY_SIZE
private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
    MAX_ARRAY_SIZE;
}

ensureCapacity方法

ArrayList源码（下面提供的是jdk8版本）中提供了一个ensureCapacity(minCapacity)方法。由于在扩容时，使用Arrays.copyOf()函数，该函数将原有的元素复制到新数组，这个操作是很浪费时间的。因此添加大量元素时，应该减少扩容次数。这时，就可以先调用ensureCapacity(minCapacity)方法，将List一次扩充至需要的大小。

public void ensureCapacity(int minCapacity) {
    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);
    }
}

---

ArrayList和Vector的区别？

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

Arraylist 与 LinkedList 区别?

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

2、底层数据结构：ArrayList底层使用的是Object数组；LinkedList底层使用的是双向链表数据结构

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

ArrayList采用数组存储，所以插入和删除元素的时间复杂度受元素位置的影响。在尾部添加时间复杂度是O(1)。如果在指定位置i插入或者删除元素（add(int index,E element)）时间复杂度就是O(n-i)。因为在进行上述操作时，需要将第i个之后的(n-i)个元素（包括第i个）向后/向前移动1位（源码中使用System.arraycopy(Object src,int srcPos,Object dest,int destPos,int length)）方法。

LinkedList采用链表存储，虽然增加或者删除操作是O(1)，但是如果需要在指定位置增加或者删除首先要遍历到这个位置，因此总的时间复杂度近似O(n)。

4、是否支持快速随机访问：LinkedList不支持高效的随机访问，而ArrayList支持。快速随机访问就是通过元素的序号快速获取元素对象

5、内存空间占用：ArrayList的空间浪费主要体现在在列表的结尾会预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗比ArrayList更多的空间（存放前驱节点和后驱节点）。

---