Java源码阅读——ArrayList

ArrayList源码阅读

起源

这里说的起源不是ArrayList，而是插个题外话，为什么要开始源码阅读？本人研二，上周接到阿里的内推电话测评面试，20分钟左右，最后问了Java基础的ArrayList。心想，这个有啥好问的，但由于当时内心还是比较紧张的，所以说的不清不楚，说到底层说了初始为10容量，每次扩容50%，但问到每次怎么实现扩容的，当时就想着是基于数组实现的，具体怎么实现的还真一时没说上来。虽说面试整体还可以，但是最后这题给我留下不小的阴影。感觉基础不扎实。确实，从开始学Java开始，都是看书和实践一些demo，而没有从源码着手。如果看懂了源码，不但理解原理，底层的实现也会很清楚。记得很早的时候一位师兄告诉我说学Java比较方便的一点是可以看源码。
千里之行，始于足下，我们慢慢来，踏踏实实！

ArrayList源码阅读

定义

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable继承了AbstractList抽象类，实现了List，RandomAccess，Cloneable，Serializable接口。后面三个为标记接口，从接口名可以看出大致意思（随机访问、可克隆、可序列化）。

成员变量

1.       private static final long serialVersionUID =8683452581122892189L;
serialVersionUID适用于Java的序列化机制。简单来说，Java的序列化机制是通过判断类的serialVersionUID来验证版本一致性的。这里了解一下就好，和ArrayList本身无关。
2.       private static final int DEFAULT_CAPACITY = 10;
默认初始容量，10
3.       private static final Object[] EMPTY_ELEMENTDATA = {};
4.       private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
上面两个放一起说，共享空常量数组，用于空的实例对象，第二个与第一个的区别文档上面是这么说的:We distinguish this from EMPTY_ELEMENTDATA to know how much toinflate when first element is added., 翻译一下就是与EMPTY_ELEMENTDATA数组的区别在于当第一个元素被加入进来的时候它知道如何扩张；看下面add(E e)源码中的第一行代码中的所在的函数就是这句话的实现。
5.       transient Object[] elementData;
用来存储ArrayList中的元素，很明显，底层是基于数组实现的。
6.       private int size;
记录ArrayList中存储元素的个数。

构造方法

构造方法有三个：public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}构造一个初始容量为10的空列表。
 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(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;
    }
}构造一个包含指定collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。
 

成员方法

add(E e)

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

modCount为AbstractList继承来的字段，表示修改了多少次。
ensureCapacityInternal(size + 1)，私有方法，增加元素后是否超过容量需要扩容。
add方法操作就是对数组上的操作。

add(int index, E element)

public void add(int index, E element) {
    rangeCheckForAdd(index);

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

私有方法rangeCheckForAdd(index)，检查index的合法性在0~size之间。
其他同add(E e)方法。

addAll(Collection<? extends E> c)

按照指定collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素添加到此列表的尾部public boolean addAll(Collection<? extends E> c) {
    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacityInternal(size + numNew);  // Increments modCount
    System.arraycopy(a, 0, elementData, size, numNew);
    size += numNew;
    return numNew != 0;
}先将collection转换为数组，然后检查是否需要扩容，使用本地方法进行数组复制。

addAll(int index, Collection<? extends E> c)

从指定的位置开始，将指定collection 中的所有元素插入到此列表中。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)
        System.arraycopy(elementData, index, elementData, index + numNew,
                         numMoved);

    System.arraycopy(a, 0, elementData, index, numNew);
    size += numNew;
    return numNew != 0;
}同样检查index合法性，判断扩容，先将elementData数组位置空出来，然后将插入的值复制进去。

clear()

public void clear() {
    modCount++;

    // clear to let GC do its work
    for (int i = 0; i < size; i++)
        elementData[i] = null;

    size = 0;
}

不用解释，全置为null。

clone()

返回此 ArrayList 实例的浅表副本。public Object clone() {
    try {
        ArrayList<?> v = (ArrayList<?>) super.clone();
        v.elementData = Arrays.copyOf(elementData, size);
        v.modCount = 0;
        return v;
    } catch (CloneNotSupportedException e) {
        // this shouldn't happen, since we are Cloneable
        throw new InternalError(e);
    }
}很明显，只是复制了一份引用到新的ArrayList中。

contains(Object o)

public boolean contains(Object o) {
    return indexOf(o) >= 0;
}

返回该对象在该list中的下标是否在合法范围内，从而得出是否包含该元素。

ensureCapacity(int minCapacity)

如有必要，增加此ArrayList 实例的容量，以确保它至少能够容纳最小容量参数所指定的元素数。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);
    }
}如果elementData为DEFAULTCAPACITY_EMPTY_ELEMENTDATA，则最小扩展10，否则为0。然后判断minCapacity是否需要扩容情况。

get(int index)

返回此列表中指定位置上的元素。public E get(int index) {
    rangeCheck(index);

    return elementData(index);
}先检查index合法性，然后返回底层数组的元素。

indexOf(Object o)

返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。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;
}使用Object的equals()方法进行判断，是否为同一元素，返回下标，不存在返回-1。

isEmpty()

判断列表是否为空public boolean isEmpty() {
    return size == 0;
}直接返回size==0

lastIndexOf(Object o)

返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -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;
}同上相反，for循环初始条件可以看出，从后往前。

remove(int index)

 移除此列表中指定位置上的元素。public E remove(int index) {
    rangeCheck(index);

    modCount++;
    E oldValue = elementData(index);

    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

    return oldValue;
}检查index合法性，保存需要remove的值在oldValue中，移动底层数组，减少容量，返回oldValue。

remove(Object o)

移除此列表中首次出现的指定元素（如果存在）。public boolean remove(Object o) {
    if (o == null) {
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
                fastRemove(index);
                return true;
            }
    } else {
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}和indexOf(Objecto)类似，先找到元素，然后执行fastRemove()（元素移动），注意返回值和remove(int index)不同。

set(int index, E element)

用指定的元素替代此列表中指定位置上的元素。public E set(int index, E element) {
    rangeCheck(index);

    E oldValue = elementData(index);
    elementData[index] = element;
    return oldValue;
}检查合法性，保存原值oldValue，将新值插入，返回oldValue。

size()

返回列表长度public int size() {
    return size;
}

toArray()

按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组。public Object[] toArray() {
    return Arrays.copyOf(elementData, size);
}返回elementData一份浅拷贝。

toArray(T[] a)

按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。public <T> T[] toArray(T[] a) {
    if (a.length < size)
        // Make a new array of a's runtime type, but my contents:
        return (T[]) Arrays.copyOf(elementData, size, a.getClass());
    System.arraycopy(elementData, 0, a, 0, size);
    if (a.length > size)
        a[size] = null;
    return a;
}这里需要判断数组a的长度，返回相同的拷贝。

trimToSize()

将此 ArrayList 实例的容量调整为列表的当前大小。public void trimToSize() {
    modCount++;
    if (size < elementData.length) {
        elementData = (size == 0)
          ? EMPTY_ELEMENTDATA
          : Arrays.copyOf(elementData, size);
    }
}由于列表的增加删除，导致列表有多余空间需要释放（实际的size小于elementData数组的实际大小）。如果为空，则变为EMPTY_ELEMENTDATA，否则复制数组。

private void grow(int minCapacity)

ArrayList的一个扩容操作，私有方法，底层自动扩容，保证列表中容得下minCapacity大小的元素。
很明显，每次扩容newCapacity= oldCapacity + (oldCapacity >> 1)，如果还不够就直接扩容为newCapacity，如果这个newCapacity比MAX_ARRAY_SIZE还大，则扩容到Integer.MAX_VALUE，一般用不到吧。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);
} 

小结

看完源码，其实ArrayList比较简单，看的也很快，没有难懂的地方，但是看完后思路会更加清晰，比看所有书本上说的要更容易理解透彻。
后续会继续阅读一些Java源码，然后扩展到一些框架的源码阅读，加油！