Java容器类浅析四----ArrayList和LinkedList的存取原理

一、概述

数组和列表是Java容器类中最经常使用的一类。
列表的底层存储数据结构是Object的数组，数组是静态的，而列表的长度是可以动态增长的，可以称之为“动态数组”。
列表长度的动态增长，是在add时检查当前元素个数是否达到了数组的边界，如果达到了，则创建一个长度为当前数组长度1.5倍的新数组，并将之前的数据copy到新的数组中；copy时调用Native Method—System.arrayCopy，该方法是C/C++的实现，可以直接操作指针，实现快速拷贝。

链式列表的底层存储结构是Node节点组成的双向链表，通过first节点和last节点来链接所有的节点，每次add元素时如果没有指定index，则将元素插入到尾部。

二、成员变量

/**
 * Default initial capacity.
 * 默认的数组长度为10，当size超过10以后，每次size >= elementData.legth时，capacity都会增加50%
 */
private static final int DEFAULT_CAPACITY = 10;

/**
 * Shared empty array instance used for empty instances.
 * 和HashMap的EMPTY_TABLE一样的作用，初始化时赋值给elementData
 */
private static final Object[] EMPTY_ELEMENTDATA = {};

/**
 * The array buffer into which the elements of the ArrayList are stored.
 * The capacity of the ArrayList is the length of this array buffer. Any
 * empty ArrayList with elementData == EMPTY_ELEMENTDATA will be expanded to
 * DEFAULT_CAPACITY when the first element is added.
 * 列表中存储结构
 */
private transient Object[] elementData;

/**
 * The size of the ArrayList (the number of elements it contains).
 *列表中元素的个数，不同于elementData.length
 * @serial
 */
private int size;

三、构造函数

/**
*指定数组的长度，长度必须为自然数
*/
public ArrayList(int initialCapacity) {
    super();//显示调用父类构造函数
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    this.elementData = new Object[initialCapacity];
}

/**
 * 初始化数组为空数组
 */
public ArrayList() {
    super();
    this.elementData = EMPTY_ELEMENTDATA;
}

/**
 *将一个Collection子类的对象转为ArrayList对象。
 */
public ArrayList(Collection<? extends E> c) {
    elementData = c.toArray();获取元素的数组
    size = elementData.length;
    // c.toArray might (incorrectly) not return Object[] (see 6260652)
    //确保数组的类型是Object，以免导致方法签名不正确的错误
    if (elementData.getClass() != Object[].class)
        elementData = Arrays.copyOf(elementData, size, Object[].class);
}

四、主要方法分析

1. add()相关方法

public boolean add(E e) {
  //在插入数据时首先检查当前数组容量是否足够
    ensureCapacityInternal(size + 1);  // Increments modCount!!
  //每次插入的元素存放在数组的尾部，这样可以避免造成其他元素的移动，尾插法的时间空间效率都为O(1)
    elementData[size++] = e;
    return true;
}

private void ensureCapacityInternal(int minCapacity) {
    //第一次调用add方法时，才会对数组设定长度，默认长度为10
    if (elementData == EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }

    ensureExplicitCapacity(minCapacity);
}

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;//Fail-Fast策略

    // overflow-conscious code  自我增长
    //第一次 数组长度从0增长到10，以后每次需要增长时，长度增加50%
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

/**
*增长函数
*/
private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);//容量增加50%
    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);
}

指定插入位置的add方法

public void add(int index, E element) {
    rangeCheckForAdd(index);//首先检查位置是否越界

    ensureCapacityInternal(size + 1);  // 检查是否需要对数组进行扩容 

    //
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    elementData[index] = element;
    size++;
}

LinkedList的源码较为简单，这里就不再一一分析了。可参见深入Java集合学习系列：LinkedList的实现原理