基于JDK1.8剖析ArrayList源码

ArrayList 是一个数组队列，相当于 动态数组。与Java中的数组相比，它的容量能动态增长。它继承于AbstractList，实现了List, RandomAccess, Cloneable, java.io.Serializable这些接口。

在IDEA中通过Ctrl+Alt+U可以查看到继承关系。

 

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

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

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

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

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

 

ArrayList构造函数

    //可传入初始容量大小构造函数，当传入为0时会分配容量为0的Object类型数组
    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);
        }
    }


    //空参传入时并不会为其分配空间
    //private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    //类内定义了DEFAULTCAPACITY_EMPTY_ELEMENTDATA没有元素的Object类型数组
    //只有当调用add()方法时才会初始化容量为10，这与JDK1.6中空参就创建容量为10的Object数组是不同的
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }


    //创建了一个包含collection的ArrayList
    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;
        }
    }

 

关键函数：

    //由该方法调用grow来实现动态扩容
    //目的在于解耦，将真正用于扩容的方法gorw()抽象出来
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

 
    //确立数组扩容的上限，-8的原因在于有的虚拟机需要一个单元大小来存放数组的容量
    //并且在序列化传输时会将this.size写入数组一起序列化传入，接收方先读到size确定数组大小才能知道该读取多少字节
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;


    //真正的用于增长数组容量的函数
    //JDK1.6中扩容公式是：新的容量=“(原始容量x3)/2 + 1”  扩容1.5倍
    //JDK1.8中扩容公式为：新的容量=“原始容量+（原始容量/2）”，扩容1.5倍，容量计算比JDK1.6简单，有一点性能上的优化
    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);
    }

    //当grow()函数接收到的参数大于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;
    }

 

• 在源码中我们可以看到在调用add(),addAll(),readObject()方法时都会调用ensureCapacity()方法或者ensureCapacityInternal()方法，其作用一个是检查this.size是否合规，另一方面是在扩容前对参数进行检查，是否查过最大容量限制。当参数检查合规后再调用ensureExplicitCapacity()对数组进行动态扩容。

 

• ArrayList包含了两个重要的对象：elementData 和 size。elementData 是"Object[]类型的数组"，它保存了添加到ArrayList中的元素，对外不可见。size 则是动态数组的实际大小。

 

• ArrayList调用默认构造函数时并不会为其分配数组，而是在调用add()方法后对数组进行检查，如果发现没有容量再分配大小为10的Object数组。这与JDK1.6是不同的，JDK1.6调用默认构造函数后会马上分配容量为10的Object数组。
• 另外也要注意JDK1.8与JDK1.6的数组容量增长公式也是不同的，但最终大小每次增长都是1.5倍。
• ArrayList的克隆函数，即是将全部元素克隆到一个数组中。
• ArrayList实现java.io.Serializable的方式。当写入到输出流时，先写入“容量”，再依次写入“每一个元素”；当读出输入流时，先读取“容量”，再依次读取“每一个元素”。

 

ArrayList的三种遍历方式：

//第一种迭代器方式
Integer value = null;
Iterator iter = list.iterator();
while (iter.hasNext()) {
    value = (Integer)iter.next();
}

//第二种随机访问，通过索引值
Integer value = null;
int size = list.size();
for (int i=0; i<size; i++) {
    value = (Integer)list.get(i);        
}

//第三种forezch
Integer value = null;
for (Integer integ:list) {
    value = integ;
}

其中遍历ArrayList时，使用随机访问(即，通过索引序号访问)效率最高，而使用迭代器的效率最低。

 

调用toArray异常:

调用 toArray() 函数会抛出“java.lang.ClassCastException”异常，但是调用 toArray(T[] contents) 能正常返回 T[]。

toArray() 会抛出异常是因为 toArray() 返回的是 Object[] 数组，将 Object[] 转换为其它类型(如如，将Object[]转换为的Integer[])则会抛出“java.lang.ClassCastException”异常，因为Java不支持向下转型。具体的可以参考前面ArrayList.java的源码介绍部分的toArray()。
解决该问题的办法是调用 <T> T[] toArray(T[] contents) ， 而不是 Object[] toArray()。

调用 toArray(T[] contents) 返回T[]的可以通过以下方式实现。

public static Integer[] vectorToArray2(ArrayList<Integer> v) {
    Integer[] newText = (Integer[])v.toArray(new Integer[0]);
    return newText;
}

---

文中部分内容摘自 http://www.cnblogs.com/skywang12345/p/3308556.html

还有关于fail-fast的内容该博主写的也很棒，请移步http://www.cnblogs.com/skywang12345/p/3308556.html 阅读