JAVA数据结构——集合之ArrayList

盗图一张，找不到原作者了，如有知道原链接的朋友，请告知，谢谢。

java的集合继承关系，第一个让我感觉有些头疼的JAVA知识点，初学时复杂的继承关系让我有点无所适从。今天开始重新梳理自己半年来的知识点，补充体系上的漏洞，个人水平还属于初级阶段，有概念错误或疏漏，也请各位朋友指正与补充，谢谢。

从List入手，依次梳理各常用数据结构的源码与原理，List下面常用的数据结构有ArrayList、LinkedList、Vector（线程安全，效率问题目前基本不用）。

ArrayList，动态数组，内部包含了一个数组，在此基础之上根据继承关系，封装了一组方法，常用的方法如下：

• ArrayList()
• ArrayList(int initialCapacity)
• ArrayList(Collection<? extends E> c)
• boolean add(E e)
• public Iterator<E> iterator()

ArrayList()

    /**
     * 构造一个空的ArrayList，初始容量为10.
     */

    private static final int DEFAULT_CAPACITY = 10;

    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

ArrayList(int initialCapacity) 

    /**
     * 以指定的容量创建一个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);
        }
    }

ArrayList(Collection<? extends E> c)

    /**
     * 以现有的集合作为初始值，创建一个新的ArrayList，
     * 新的ArrayList为原集合的一个副本。
     *
     * @param c the collection whose elements are to be placed into this list
     * @throws NullPointerException if the specified collection is null
     */
    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;
        }
    }    

boolean add(E e)

ArrayList添加新元素，需要计算添加一个新元素后，当前ArrayList的容量是否足够。如果容量不够，需要将当前容量扩充至当前容量的1.5倍，如果超过虚拟机的最大限制，则截断详细如下：

/**
     * Appends the specified element to the end of this list.
     *
     * @param e element to be appended to this list
     * @return <tt>true</tt> (as specified by {@link Collection#add})
     */
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

    private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

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

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

    /**
     * Increases the capacity to ensure that it can hold at least the
     * number of elements specified by the minimum capacity argument.
     *
     * @param minCapacity the desired minimum capacity
     */
    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);
        // 创建新数组的拷贝
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

add(E e)

public Iterator<E> iterator()：返回一个Iterator类型的内部类对象，该对象包含了可以操作ArrayList对象的一些Iterator方法，入next、hasNext等方法

    public Iterator<E> iterator() {
        return new Itr();
    }

    /**
     * Returns an iterator over the elements in this list in proper sequence.
     *
     * <p>The returned iterator is <a href="#fail-fast"><i>fail-fast</i></a>.
     *
     * @return an iterator over the elements in this list in proper sequence
     */
    public Iterator<E> iterator() {
        return new Itr(); //创建一个新的内部类对象，该对象包含了对ArrayList对象的常用操作方法，next()、hasNext()、remove()等方法
    }

    /**
     * An optimized version of AbstractList.Itr
     */
    private class Itr implements Iterator<E> {
        int cursor;       // 当前被操作的元素，默认为0
        int lastRet = -1; // 上一个被操作的元素，如果没有则为-1（初始时或上一个元素被删除时，则为0）
        int expectedModCount = modCount;

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

        @SuppressWarnings("unchecked")
        public E next() {
            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];
        }

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

            try {
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }
    }

以上是ArrayList中常用且典型的方法源码，理解上面的源码有助于帮助我们理解ArrayList的工作原理和特点。ArrayList在集合中是比较简单，但是非常常用的数据结构，了解了ArrayList可以让我们在合适的场景去使用它。