ArrayList源码解析

JDK1.8源码分析之ArrayList

构造图如下：

蓝色线条：继承

绿色线条：接口实现

ArrayList定义：

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

ArrayList是一个数组队列，相当于动态数组，与Java中的数组相比，能够实现动态增长。继承于AbstractList，实现了List、RandomAccess、Cloneable、Serializable接口。

ArrayList继承了AbstractList，实现了List接口。它是一个动态数组，提供了相关的添加、删除、修改、遍历等功能。

ArrayList实现了RandomAccess接口，即提供了随机访问的功能。RandomAccess是Java中用来被List实现，为List提供快速访问功能的。在ArrayList中，我们即可通过元素的序号快速获取元素的对象，这就是快速随机访问。

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

ArrayList实现了Serializable接口，说明ArrayList支持序列化，能通过序列化去传输。

和Vector不同，ArrayList中的操作不是线程安全的！所以建议在单线程中使用，多线程中可以使用Vector或者CopyOnWriteArrayList。

ArrayList属性

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

/**
 * ArrayList中实际数组的数量
 */
private int size;

1、elementData是“Object[ ]”类型的数组，保存添加到ArrayList中的数据。实际上elementData是一个动态数组，能通过构造函数ArrayList（int initialCapacity）来执行它的初始容量为initialCapacity。如果通过无参构造函数ArrayList（）初始化，则默认初始容量为10。elementData能够根据ArrayList容量的增长而动态增长。

2、size是动态数组的实际大小

ArrayList构造函数

/**
 * 带初始容量的大小的构造函数
 */
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);
    }
}

/**
 * 默认构造函数，默认初始容量为10
 */
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

/**
 * 构造一个包含指定元素的list，这些元素是按照collection的迭代器返回的顺序排列的
 */
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;
    }
}

• 第一个构造方法使用提供的initialCapacity来初始化elementData数组的大小。
• 第二个构造方法调用第一个构造方法并传入参数10，即默认elementData数组的大小为10。
• 第三个构造方法则将提供的集合转成数组返回给elementData（返回若不是Object[]将调用Arrays.copyOf方法将其转为Object[]）。

API摘要方法

ArrayList增加

/**
 * 添加一个元素
 */
public boolean add(E e) {
    //进行扩容检查
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    //将e添加至数组的尾部，并将容量加1
    elementData[size++] = e;
    return true;
}

/**
 * 指定位置添加一个元素
 */
public void add(int index, E element) {
    //检查是否越界
    rangeCheckForAdd(index);
    //扩容检查
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    //对数组进行赋值，目的就是空出index的位置插入element，将index后的元素移动一个位置
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    //将指定index定的位置指定为element
    elementData[index] = element;
    //list实际容量加1
    size++;
}

/**
 * 添加一个集合元素
 */
public boolean addAll(Collection<? extends E> c) {
    //将c转化为数组
    Object[] a = c.toArray();
    int numNew = a.length;
    //扩容检查
    ensureCapacityInternal(size + numNew);  // Increments modCount
    //将c添加到数组尾部
    System.arraycopy(a, 0, elementData, size, numNew);
    //数组实际容量
    size += numNew;
    return numNew != 0;
}

/**
 * 指定位置添加一个集合元素
 */
public boolean addAll(int index, Collection<? extends E> c) {
    //越界检查
    rangeCheckForAdd(index);

    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacityInternal(size + numNew);  // Increments modCount
    //计算需要移动的长度
    int numMoved = size - index;
    if (numMoved > 0)
        //数组复制，空出第index到index+numNew的位置，即将数组index后的元素向右移动numNew个位置
        System.arraycopy(elementData, index, elementData, index + numNew,
                         numMoved);
    //将要插入的数组复制到数组空出的位置
    System.arraycopy(a, 0, elementData, index, numNew);
    size += numNew;
    return numNew != 0;
}

/**
 * 数组容量检查，不够时进行扩容
 */
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);
    }
}

private void ensureCapacityInternal(int minCapacity) {
    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 static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

/**
 * 扩容
 */
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;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    //进行数据拷贝，Arrays.copyOf底层原理是System.arrayCopy()
    elementData = Arrays.copyOf(elementData, newCapacity);
}

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

ArrayList删除

/**
 * 删除指定位置的元素
 */
public E remove(int index) {
    //数组越界判断
    rangeCheck(index);

    modCount++;
    //取出要删除的元素供返回使用
    E oldValue = elementData(index);
    // 计算数组要复制的数量
    int numMoved = size - index - 1;
    if (numMoved > 0)
        //将index后的元素向前移动一个位置
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    // 将数组最后一个元素置空（因为删除了一个元素，然后index后面的元素都向前移动了，
   // 所以最后一个就没用了），好让gc尽快回收
    // 不要忘了size减一
    elementData[--size] = null; // clear to let GC do its work

    return oldValue;
}

/**
 * 根据元素内容删除，只删除匹配的第一个
 */
public boolean remove(Object o) {
    //对要删除的内容进行null判断
    if (o == null) {
        //遍历要删除的第一个元素，删除后进行返回，如果要删除最后一个元素，遍历工作量有点大
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
                fastRemove(index);
                return true;
            }
    } else {
        //非null用equals比较
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}

/*
 * Private remove method that skips bounds checking and does not
 * 原理和之前的add一样，进行数组复制，将index后的向前移动一个位置
 */
private void fastRemove(int index) {
    modCount++;
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    elementData[--size] = null; // clear to let GC do its work
}

/**
 * 越界检查
 */
private void rangeCheck(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

增加和删除方法到这里就解释完了，代码是很简单，主要需要特别关心的就两个地方：1.数组扩容，2.数组复制，这两个操作都是极费效率的，最惨的情况下(添加到list第一个位置，删除list最后一个元素或删除list第一个索引位置的元素)时间复杂度可达O(n)。

还记得上面那个坑吗（为什么提供一个可以指定容量大小的构造方法 ）？看到这里是不是有点明白了呢，简单解释下：如果数组初试容量过小，假设默认的10个大小，而我们使用ArrayList的主要操作时增加元素，不断的增加，一直增加，不停的增加，会出现上面后果？那就是数组容量不断的受挑衅，数组需要不断的进行扩容，扩容的过程就是数组拷贝System.arraycopy的过程，每一次扩容就会开辟一块新的内存空间和数据的复制移动，这样势必对性能造成影响。那么在这种以写为主（写会扩容，删不会缩容）场景下，提前预知性的设置一个大容量，便可减少扩容的次数，提高了性能。

上图分别是数组扩容和数组复制的过程，需要注意的是，数组扩容伴随着开辟新建的内存空间以创建新数组然后进行数据复制，而数组复制不需要开辟新内存空间，只需将数据进行复制。

上面讲增加元素可能会进行扩容，而删除元素却不会进行缩容，如果在已删除为主的场景下使用list，一直不停的删除而很少进行增加，那么会出现什么情况？再或者数组进行一次大扩容后，我们后续只使用了几个空间，会出现上面情况？当然是空间浪费啦啦啦，怎么办呢？

/**
 *将底层数组的容量调整至实际数组大小来释放空间
 */
public void trimToSize() {
    modCount++;
    if (size < elementData.length) {
        elementData = (size == 0)
          ? EMPTY_ELEMENTDATA
          : Arrays.copyOf(elementData, size);
    }
}

更新

/**
 * 更新指定位置元素
 */
public E set(int index, E element) {
    rangeCheck(index);

    E oldValue = elementData(index);
    elementData[index] = element;
    return oldValue;
}

查找

E elementData(int index) {
    return (E) elementData[index];
}

/**
 * 查找指定位置元素
 */
public E get(int index) {
    rangeCheck(index);

    return elementData(index);
}

是否包含

/**
 * 是否包含某个元素
 */
public boolean contains(Object o) {
    return indexOf(o) >= 0;
}

/**
 * 索引元素，从前往后
 */
public int indexOf(Object o) {
    if (o == null) {
        for (int i = 0; i < size; i++)
            if (elementData[i]==null)
                return i;
    } else {
        for (int i = 0; i < size; i++)
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;
}

/**
 * 从后往前
 */
public int lastIndexOf(Object o) {
    if (o == null) {
        for (int i = size-1; i >= 0; i--)
            if (elementData[i]==null)
                return i;
    } else {
        for (int i = size-1; i >= 0; i--)
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;
}

容量判断

/**
 * 实际容量
 *
 * @return the number of elements in this list
 */
public int size() {
    return size;
}

/**
 * Returns <tt>true</tt> if this list contains no elements.
 *
 * @return <tt>true</tt> if this list contains no elements
 */
public boolean isEmpty() {
    return size == 0;
}

总结：
(01) ArrayList 实际上是通过一个数组去保存数据的。当我们构造ArrayList时；若使用默认构造函数，则ArrayList的默认容量大小是10。
(02) 当ArrayList容量不足以容纳全部元素时，ArrayList会重新设置容量：新的容量=“(原始容量x3)/2 + 1”。
(03) ArrayList的克隆函数，即是将全部元素克隆到一个数组中。
(04) ArrayList实现java.io.Serializable的方式。当写入到输出流时，先写入“容量”，再依次写入“每一个元素”；当读出输入流时，先读取“容量”，再依次读取“每一个元素”。

ArrayList支持3种遍历方式

1）通过迭代器遍历

Integer value = null;
Iterator iter = list.iterator();
while (iter.hasNext()) {
    value = (Integer)iter.next();
}

2）随机访问通过索引值去遍历、

Integer value = null;
int size = list.size();
for (int i=0; i<size; i++) {
    value = (Integer)list.get(i);
}

3）通过for循环遍历  

Integer value = null;
for (Integer integ:list) {
    value = integ;
}

在三种遍历中，使用随机遍历访问的效率是最高的，使用迭代器遍历的效率最低。

ArrayList和LinkedList的区别

1、ArrayList基于动态数组的数据结构，LinkedList基于链表的数据结构

2、针对随机访问，ArrayList要优于LinkedList，因为LinkedList要移动指针

3、针对add和remove操作，LinkedList要优于ArrayList，因为ArrayList要移动数据

ArrayList和Vector的区别

1、ArrayList和Vector几乎是完全相同的，唯一的区别在于Vector是同步的（Syschronized），也就是线程安全的，属于强同步类。因此开销就要比ArrayList大，访问要慢。

2、Vector每次扩容都是其大小的2倍，而ArrayList是1.5倍

3、Vector有一个子类Stack

原文: http://tengj.top/2016/04/13/javajh2linklist/　　作者: 嘟嘟MD