List集合之ArrayList

一、初步了解ArrayList

         ArrayList是集合的一种实现，实现了接口List，List接口继承了Collection接口。Collection是所有集合类的父类。

         ArrayList底层是用数组实现的存储。

         特点：查询效率高，增删效率低，线程不安全。

二、继承结构

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

继承：AbstractList。
实现：List、RandomAccess、Cloneable、Serializable。

三、源码分析

一、扩容的原理add（）

数组长度有限，而ArrayList是可以存放任意数量的对象，长度不受限制，他是怎样实现的呢？

第一步：add（E e）

public boolean add(E e) {
        // 这句代码是关键，涉及首次添加元素的elementData的初始化和扩容，加入元素前检查容量是否足够
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        // 元素被添加在数组末尾
        // 没有做null检查，元素可以为null
        elementData[size++] = e;
        return true;
    }

第二步：ensureCapacityInternal(size + 1);

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);       //扩容方法
    }

第三步:grow(minCapacity);

private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        // 扩容后新的elementData大小：将数组长度增加到原来的一半
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        // 扩容后仍然不满足需要，则赋值为minCapacity
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        // 扩容后超出允许的最大数组大小
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            // 确保newCapacity最大只能为Integer.MAX_VALUE
            newCapacity = hugeCapacity(minCapacity);
        // 分配新数组，拷贝旧数据
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

以上分析可知：

1. 如果使用了默认的构造函数，那么elementData初始化大小为10.
2. 正常情况下，每次扩容后的elementData新大小=1.5倍旧大小。
3. elementData最大值只能为Integer.MAX_VALUE。

2、add(int index, E element)

public void add(int index, E element) {
        // 首先检查inde是否合法
        rangeCheckForAdd(index);

        ensureCapacityInternal(size + 1);  // 看elementData的长度是否做够，不够扩容

        // 这个地方主要为了将index位置的数据及其后的数据后移一位
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        // 将元素赋值给数组index处
        elementData[index] = element;
        size++;
    }

二、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);
        // 赋值为null，保证可以被GC回收
        elementData[--size] = null; // clear to let GC do its work

        // 返回旧的数据
        return oldValue;
    }

remove(Object o)删除列表中第一个出现O的元素

    // 删除元素。
    // 只会删除第一个出现的元素。
    public boolean remove(Object o) {
        if (o == null) {
            // for循环遍历元素。找出待删除元素的index
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);
                    // 此处导致只会删除第一个找到的相等元素
                    return true;
                }
        } else {
            // for循环遍历元素。找出待删除元素的index
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    // 此处导致只会删除第一个找到的相等元素
                    return true;
                }
        }
        return false;
    }

    // 该方法与remove(int index)基本相同
    private void fastRemove(int index) {
        modCount++;
        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
    }