深入浅出ArrayList

前言

我们一般使用集合大多都是 ArrayList，因为它查询快，一般情况下，我们很少执行增加删除操作。如果涉及到频繁的增加删除，可以使用LinkedList，基于链表的集合，增删效率较高，当然如果涉及到线程的安全问题，集合中可以使用 vector ，线程是安全的，当然也可以使用集合工具类。

下面我们先从collection中的list和set进行一个区分
集合简单版视图：

1.Collection

Collection 接口有 3 种子类型集合: List、Set 和 Queue，再下面是一些抽象类，最后是具体实现类，常用的有 ArrayList、LinkedList、HashSet、LinkedHashSet、ArrayBlockingQueue等，下面是Collection的所有方法

2.List下的ArrayList

2.1ArrayList底层

ArrayList的底层数据结构就是一个数组，数组元素的类型为Object类型，对ArrayList的所有操作底层都是基于数组的。初识容量为10.

2.2ArrayList的初始化

底层一共有3种初始化方法：
第一种：
不用传递参数，对于无参构造方法，将成员变量elementData的值设为DEFAULTCAPACITY_EMPTY_ELEMENTDATA。

    /**
     * Constructs an empty list with an initial capacity of ten.
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

第二种：
需要传递一个initialCapacity，即初始容量

    /**
     * Constructs an empty list with the specified initial capacity.
     *
     * @param  initialCapacity  the initial capacity of the list
     * @throws IllegalArgumentException if the specified initial capacity
     *         is negative
     */
    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);
        }
    }

第三种：

    /**
     * Constructs a list containing the elements of the specified
     * collection, in the order they are returned by the collection's
     * iterator.
     *
     * @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;
        }
    }

2.3 ArrayList 扩容机制

第一，在add()方法中调用ensureCapacityInternal(size + 1)方法来确定集合确保添加元素成功的最小集合容量minCapacity的值。参数为size+1，代表的含义是如果集合添加元素成功后，集合中的实际元素个数。换句话说，集合为了确保添加元素成功，那么集合的最小容量minCapacity应该是size+1。在ensureCapacityInternal方法中，首先判断elementData是否为默认的空数组，如果是，minCapacity为minCapacity与集合默认容量大小中的较大值。

    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 static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

第二，调用ensureExplicitCapacity(minCapacity)方法来确定集合为了确保添加元素成功是否需要对现有的元素数组进行扩容。首先将结构性修改计数器加一；然后判断minCapacity与当前元素数组的长度的大小，如果minCapacity比当前元素数组的长度的大小大的时候需要扩容，进入第三阶段。

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

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

第三，如果需要对现有的元素数组进行扩容，则调用grow(minCapacity)方法，参数minCapacity表示集合为了确保添加元素成功的最小容量。在扩容的时候，首先将原元素数组的长度增大1.5倍（oldCapacity + (oldCapacity >> 1)），然后对扩容后的容量与minCapacity进行比较：① 新容量小于minCapacity，则将新容量设为minCapacity；②新容量大于minCapacity，则指定新容量。最后将旧数组拷贝到扩容后的新数组中。

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

第四，如果新的容量大于最大容量的话，执行hugeCapacity方法

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

第五，调用Arrays.copeOf方法

    public static <T> T[] copyOf(T[] original, int newLength) {
        return (T[]) copyOf(original, newLength, original.getClass());
    }

图解add方法：

3.ArrayList代码示例

（1）当添加1个元素时：

        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        //通过反射来获取ArrayList的容量
        Class<? extends List> strClass = list.getClass();
        Field field = strClass.getDeclaredField("elementData");
        field.setAccessible(true);
        Object [] elementData = (Object[]) field.get(list);

        System.out.println("ArrayList的容量为："+elementData.length);
        System.out.println("ArrayList的长度为："+list.size());

运行结果：

ArrayList的容量为：10
ArrayList的长度为：1

（2）当添加了11个元素时

        ArrayList<Integer> list = new ArrayList<>();
        for(int i = 1; i<= 11; i++){
            list.add(i);
        }

        //通过反射来获取ArrayList的容量
        Class<? extends List> strClass = list.getClass();
        Field field = strClass.getDeclaredField("elementData");
        field.setAccessible(true);
        Object [] elementData = (Object[]) field.get(list);

        System.out.println("ArrayList的容量为："+elementData.length);
        System.out.println("ArrayList的长度为："+list.size());

运行结果：

ArrayList的容量为：15
ArrayList的长度为：11

4.自我实现ArrayList

实现请点击此处：ArrayList的自我实现

5.ArrayList的优缺点

（1）优点
ArrayList查询快，可以通过数组下标快速查询到数据
（2）缺点
ArrayList插入和删除比较慢，因为要频繁的移动元素
（3）扩容规则
每次扩容现有容量的50%。