ArrayList

类图

• 实现了RandomAccess接口，可以随机访问
• 实现了Cloneable接口，可以克隆
• 实现了Serializable接口，可以序列化、反序列化
• 实现了List接口，是List的实现类之一
• 实现了Collection接口，是Java Collections Framework成员之一
• 实现了Iterable接口，可以使用for-each迭代

属性

    /**
     *  序列化版本UID
     */
    private static final long serialVersionUID = 8683452581122892189L;

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

    /**
     * 用于空实例的共享空数组实例
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

    /**
     * 用于提供默认大小的共享空数组实例
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    /**
     * 存储ArrayList元素的数组缓冲区
     * 数组的长度是ArrayList的容量
     * 用transient修饰，不可实例化
     * 为什么没有被private修饰？非私有以简化嵌套类访问。
     */
    transient Object[] elementData; 

    /**
     * 元素个数
     */
    private int size;

构造方法

1.带初始容量的构造方法

 /**
     * 带一个初始容量的构造参数
     *
     * @param  initialCapacity  list的初始容量
     * @throws IllegalArgumentException 如果初始容量不合法就抛出 IllegalArgumentException 异常
     */
    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);
        }
    }

• 如果初始容量大于0，就创建一个容量为初始容量的Object数组，并将数组的引用赋值给elementData；如果初始容量等于0，就将EMPTY_ELEMENTDATA赋值给elementData；否则，抛出IllegalArgumentException。

2.无参构造方法

    /**
     * 无参构造器，默认初始容量是10
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

• 虽然ArrayList的无参构造器默认初始容量是10，不过它并没有创建数组，只是将elemetnData赋值为DEFAULTCAPACITY_EMPTY_ELEMENTDATA，等到添加第一个元素的时候，再创建数组。

3.带一个集合参数的构造方法

    /**
     * 创建一个集合包含集合参数的元素
     *
     * @param c 集合中的元素会被放到List中
     * @throws NullPointerException 如果参数 c 是null,抛出NullPointerException
     */
    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray可能不返回Object[]
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            //size==0,将elementData赋值为EMPTY_ELEMENTDATA
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

插入方法

1.在尾部添加一个元素

    //在尾部添加元素
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // 增加 modCount!!
        elementData[size++] = e;
        return true;
    }

• 在父类AbstractList上，定义了modCount 属性，用于记录数组修改的次数。对数组进行结构化修改时modCount加一，包括添加元素，删除元素。
• 在尾部添加元素前要做的主要就两件事，第一要确保不会溢出，第二把modCount加一。调用ensureCapacityInternal函数完成这两件事。如果是使用了无参构造函数而且是第一次添加元素，会将数组扩容到默认容量10；如果是原来的数组长度小于需要的容量，会将数组扩容到原来的3/2倍。
• 将要添加的元素赋值给elementData[size],并将size加一。

2.在指定位置添加元素

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

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

• 如果指定位置已经有元素，就调用System.arraycopy方法，将该元素和随后的元素移动到右面一位。

3.添加元素用到的私有方法

private void ensureCapacityInternal(int minCapacity) {
        //从这里可以看到，调用无参构造函数的话，添加第一个元素时会将默认容量10和minCapacity的较小值赋值给 minCapacity
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

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

        // 如果 minCapacity 大于数组的长度，就进行扩容
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

扩容方法

    /**
     * 数组的最大容量
     * 一些虚拟机在数组中预留一些header words,如果尝试分配更大的size，可能导致OutOfMemoryError
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    /**
     * 增加容量，至少保证容量大于传入的参数 minCapacity
     * @param minCapacity
     */
    private void grow(int minCapacity) {
        
        int oldCapacity = elementData.length;
        //一般情况下，新容量是原来容量的3/2倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //如果原来容量的3/2倍小于 minCapacity，那么将 minCapacity 赋值给新容量
        if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
        //如果新容量比MAX_ARRAY_SIZE还要大的话，如果 minCapacity 大于 MAX_ARRAY_SIZE，
        //则新容量是Integer.MAX_VALUE,不然新容量是 MAX_ARRAY_SIZE
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
       
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

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

• MAX_ARRAY_SIZE 定义为 Integer.MAX_VALUE - 8,ArrayList作者对所需的额外头文字的最大数量的估计为8，作为数组，在64位机器下，它本身需要8 bytes存储大小。
• 通常情况新容量是原来容量的1.5倍;如果原容量的1.5倍比minCapacity小，那么就扩容到minCapacity;特殊情况扩容到Integer.MAX_VALUE。
• Arrays.copyOf方法底层调用了System.Arraycopy方法，返回一个新数组。

    public static <T> T[] copyOf(T[] original, int newLength) {
        return (T[]) copyOf(original, newLength, original.getClass());
    }
    
    public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
        @SuppressWarnings("unchecked")
        T[] copy = ((Object)newType == (Object)Object[].class)
            ? (T[]) new Object[newLength]
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

删除方法

1.删除指定下标的元素

    public E remove(int index) {
        //检查下标
        rangeCheck(index);
        //modCount加一
        modCount++;
        //取出要删除位置的元素，用来做返回值
        E oldValue = elementData(index);

        //将要删除位置之后的元素向前移动一个位，如果是最后一个元素，numMoved==0，直接将elementData[size]置空即可
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // 将引用置空，让GC回收


        return oldValue;
    }

2.删除指定元素

    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;
    }

• ArrayList允许元素是null值，删除指定元素需要判断要删除的是不是null值分开处理，遍历数组，如果是要删除的值，调用fastRemove方法删除。

3.删除元素用到的私有方法

    /**
     * 私有的 移除 方法 跳过边界检查且不返回移除的元素
     * @param index
     */
    private void fastRemove(int index) {
        modCount++;
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        //将引用置空，让GC回收
        elementData[--size] = null; // clear to let GC do its work
    }

查找方法

1.查找指定元素的位置

    /**
     * 返回指定元素的第一次出现的位置，如果没有，返回-1。
     * @param o 要查找的元素
     * @return
     */
    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;
    }

• 和删除指定元素类似，也要分删除的值是不是null分开处理，从头遍历数组，如果等于要查找的元素就返回位置索引。

2.查找指定位置的元素

    /**
     * 返回指定位置的元素
     * @param index 要返回元素的位置
     * @return
     *  @throws IndexOutOfBoundsException index越界会抛出IndexOutOfBoundsException
     */
    public E get(int index) {
        rangeCheck(index);

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

• ArrayList支持随机访问，查找指定位置的元素直接返回elementData数组指定下标的元素，时间复杂度是O(1)的。

序列化方法

1.序列化

    /**
     * 保存ArrayList的状态到一个流（序列化）
     * @param s
     * @throws java.io.IOException
     */
    private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException{
        // Write out element count, and any hidden stuff
        int expectedModCount = modCount;
        s.defaultWriteObject();

        // Write out size as capacity for behavioural compatibility with clone()
        s.writeInt(size);

        // Write out all elements in the proper order.
        for (int i=0; i<size; i++) {
            s.writeObject(elementData[i]);
        }

        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }

2.反序列化

    /**
     * 重建ArrayList实例通过一个流（反序列化）
     * @param s
     * @throws java.io.IOException
     * @throws ClassNotFoundException
     */
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        elementData = EMPTY_ELEMENTDATA;

        // Read in size, and any hidden stuff
        s.defaultReadObject();

        // Read in capacity
        s.readInt(); // ignored

        if (size > 0) {
            // be like clone(), allocate array based upon size not capacity
            ensureCapacityInternal(size);

            Object[] a = elementData;
            // Read in all elements in the proper order.
            for (int i=0; i<size; i++) {
                a[i] = s.readObject();
            }
        }
    }

• 序列化时，先写入size，再写入每一个元素；反序列化时，先读取size，再读取每一个元素。
• elementData之所以用transient修饰，是因为JDK不想将整个elementData都序列化或者反序列化，而只是将size和实际存储的元素序列化或反序列化，从而节省空间和时间。

克隆方法

    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的克隆是浅克隆，将全部元素复制到一个新数组返回。

迭代器

1.创建迭代器方法

   /**
     * 返回的迭代器是“快速失败”的
     * @return 一个按适当的顺序遍历列表中元素的迭代器
     */
    public Iterator<E> iterator() {
        return new Itr();
    }

2.Itr类的属性

    private class Itr implements Iterator<E> {
        int cursor;       //下一个要返回的元素的下标  
        int lastRet = -1; //最后一个要返回元素的下标，如果没有返回 -1 
        int expectedModCount = modCount;//期望的modCount
    }

3.Itr类的next方法和hasNext方法

        public boolean hasNext() {
            return cursor != size;
        }

        @SuppressWarnings("unchecked")
        public E next() {
            //调用next()方法会检查对象有没有发生结构性变化，即expectedModCount等不等于modCount
            //如果不等于就会抛出ConcurrentModificationException异常
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }
        
        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }

4.Itr类的remove方法

        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
                //调用迭代器的remove()方法来删除数据可以避免抛出 ConcurrentModificationException 异常，这里会修改expectedModCount
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

• foreach遍历删除会报ConcurrentModificatioinException异常。这是因为foreach遍历编译后实质会替换为迭代器实现，因为迭代器内部会维护一些索引位置数据，要求在迭代过程中不能发生结构性变换（添加、插入、删除），否则这些索引位置数据就失效了。在next方法中，会判断expectedModCount和modCount是否相同，不相同就抛异常。
• 避免的方式是使用迭代器的remove方法。因为在迭代器的remove方法里，会修改expectedModcount使之等于modCount。
• 普通for循环不会报这个错误，但会漏删除。解决方法可以从后向前遍历。