java集合-ArrayList

1. ArrayList特点

ArrayList实现了List接口的，底层是由一个动态数组维护着，简单地概括一下它的主要特点：
1. 允许所有类型的元素，包括null（元素可重复）
2. 数组容量可变，并提供了操控接口
3. 随机访问效率高，例如：size, isEmpty, get, set, iterator, listIterator等操作，但对于add,delete操作性能比较差
4. 非线程安全，多线程进行访问时，很可能会发生fail-fast事件

2. 主要属性

private static final int DEFAULT_CAPACITY = 10; //默认初始化容量 为10
private static final Object[] EMPTY_ELEMENTDATA = {}; //初始化空ArrayList时elementData==EMPTY_ELEMENTDATA
private transient Object[] elementData;//储存元素的数组
private int size;//ArrayList的大小，即元素数目
protected transient int modCount = 0;//结构上被修改(令到size改变的操作)的次数，通过该值来判断是否会发生fail-fast事件

3. ArrayList构造

3.1 使用默认构造函数

 public ArrayList() {
        super();
        this.elementData = EMPTY_ELEMENTDATA; //构造一个空ArrayList，此时数量为0，当第一个元素被add时会进行扩容
    }

3.2 指定容量构造空的List

 public ArrayList(int initialCapacity) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];
    }

3.3 通过Collection实例构造List

public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        size = elementData.length;
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    }

ArrayList包含了c中所有的元素对象，而且在顺序上与c的迭代器返回的元素顺序保持一致

4. 添加元素

 public boolean add(E e) {
        ensureCapacityInternal(size + 1);  //确保容量，不足的进行扩容
        elementData[size++] = e;
        return true;
    }

可以看得出，每次在添加元素时都会先调用ensureCapacityInternal进行扩容以保证数组有足够的空间容纳新的元素，新添加的元素会默认放置于数组的末尾。

 public void add(int index, E element) {
        rangeCheckForAdd(index);//检查插入的位置是否合理

        ensureCapacityInternal(size + 1);  // 确保容量，不足的进行扩容
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index); //把index往后的所有元素后移到一位
        elementData[index] = element; //在第index位置插入新元素
        size++;
    }

相对比于add(E e)方法，多了一步操作，就是把index往后的所有元素后移到一位

5. 删除元素

  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); //把第index+1往后的元素前移一位
        elementData[--size] = null; // 把最后位置元素设置为null，使得回收内存

        return oldValue;
    }

删除第index个元素，只需要把index+1至最后一个元素往前移动一位，并把最后一个空出的位置设置为null，方便垃圾回收。

 public boolean remove(Object o) {
        if (o == null) {
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index); //与remove(int index)差不多
                    return true;
                }
        } else {
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }

从数组中删除o元素，遍历数组所有的元素，一个一个与o元素对比，如果存在o元素，则记录下标index，并把该位置的元素从elementData[]里删除。由于o可以为null，所以需要分为两种方式判断是否相等，如果是元素是自定义的类对象，最好实现equals方法。

//从List中删除所有包含c集合的元素
  public boolean removeAll(Collection<?> c) {
        return batchRemove(c, false);
    }
//从List中保留所有包含c集合的元素
public boolean retainAll(Collection<?> c) {
        return batchRemove(c, true);
    }

上两个方法其实都是互补的，主要看batchRemove的实现：

private boolean batchRemove(Collection<?> c, boolean complement) { //complement可以译作补集的意思，为true时保留包含的元素，为false时保留不包含的元素
        final Object[] elementData = this.elementData;
        int r = 0, w = 0;
        boolean modified = false;
        try {
            for (; r < size; r++)
                if (c.contains(elementData[r]) == complement)
                    elementData[w++] = elementData[r];  //把需要保留的元素顺序从数据头放置w++
        } finally {
            //其实是为了避免elememtData出现脏数据（重复），因为在上面for循环中的c.contains()方法中可能抛出异常，导致循环半途中断，把未判断的元素复制到数组尾部
            if (r != size) {
                System.arraycopy(elementData, r,
                                 elementData, w,
                                 size - r);
                w += size - r;
            }
            if (w != size) {
                // clear to let GC do its work
                for (int i = w; i < size; i++)
                    elementData[i] = null;
                modCount += size - w;
                size = w;
                modified = true;
            }
        }
        return modified;
    }

 protected void removeRange(int fromIndex, int toIndex) {
        modCount++;
        int numMoved = size - toIndex;
        System.arraycopy(elementData, toIndex, elementData, fromIndex,
                         numMoved);//把toIndex往后的元素向前移动

        // clear to let GC do its work
        int newSize = size - (toIndex-fromIndex);
        for (int i = newSize; i < size; i++) {
            elementData[i] = null;
        }
        size = newSize;
    }

删除某个范围内的元素，把toIndex往后的元素向前移动到从fromIndex位置开始，最后空闲的位置设置为null方便垃圾回收。

6. 修改元素

 public E set(int index, E element) {
        rangeCheck(index);

        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }

替换index位置的元素，并返回旧的元素

6. 迭代器

ArrayList内部实现了两种迭代器：Itr以及ListItr，ListItr扩展了Itr，不仅支持hashNext,next,remove操作，还实现了add,hasPrevious,previous,set等方法。

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

平常最常用的iterator()方法，返回的就是一个Itr对象，看一下它的主要属性:

int cursor;       // 当前访问的元素的下标
int lastRet = -1; // 上一个返回的元素的下标，-1表示没有
int expectedModCount = modCount;//前面已经说过modCount是用来判断是否发生fail-fast事件，初始化时两者相等

Itr以及ListItr的方法如果是涉及到访问元素，例如：next,remove,previous,set都会先调用checkForComodification方法来检查当前的List是否被修改

final void checkForComodification() {
            if (modCount != expectedModCount)  //如果两者不相等，说明当前还有别的线程在对List进行着结构上的修改
                throw new ConcurrentModificationException();
        }

当某一个线程A通过iterator去遍历某集合的过程中，若该集合的内容被其他线程所改变了；那么线程A访问集合时，就会抛出ConcurrentModificationException异常，产生fail-fast事件。迭代器的快速失败行为无法得到保证，它不能保证一定会出现该错误，但是快速失败操作会尽最大努力抛出ConcurrentModificationException异常，所以因此，为提高此类操作的正确性而编写一个依赖于此异常的程序是错误的做法，正确做法是：ConcurrentModificationException 应该仅用于检测 bug。

7. 动态扩容

每当把元素添加到List中来的时候都会调用ensureCapacityInternal方法来确保数组的容量能够存放得下加入的元素，虽然如此，但如果能在使用ArrayList之前估计容量从而初始化一个合适容量的List，还是能够避免一此不必要的性能开销。

private void ensureCapacityInternal(int minCapacity) {
        if (elementData == EMPTY_ELEMENTDATA) { //首次向List添加元素
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity); //初始容量最小为10
        }

        ensureExplicitCapacity(minCapacity);
    }

minCapacity是申请的容量，如果是ArrayList内部自动扩容，那么它的值为旧容量大小+添加的元素数，当然，使用者也可以通过调用公有方法ensureCapacity手动传入容量参数进行扩容。最后调用ensureExplicitCapacity方法

private void ensureExplicitCapacity(int minCapacity) {
        modCount++; //表示List当前被修改一次

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

如果申请的容量大小比原本数组的还要大，说明没有足够的容量，此时调用grow方法把容量调整更大

 private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1); //新容量为旧容量 的1.5倍
        if (newCapacity - minCapacity < 0) //新容量不能比minCapacity小
            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进行扩容时，都要满足3点要求：
1. 新容量为旧容量的1.5倍
2. 新容量不能比申请的容量(minCapacity)小
3. 新容量不能大于最大容Integer.MAX_VALUE=2147483647，其实内部建议的最大容量应该是MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8=2147483639

MAX_ARRAY_SIZE：
The maximum size of array to allocate. Some VMs reserve some header words in an array. Attempts to allocate larger arrays may result in OutOfMemoryError: Requested array size exceeds VM limit.
有些java虚拟机的实现还会保留一些头部信息在array中，如果分配的容量大于MAX_ARRAY_SIZE那么有可能会出现OOM.

8. 其它操作

public void trimToSize() {
        modCount++;
        if (size < elementData.length) {
            elementData = Arrays.copyOf(elementData, size);
        }
    }

消减容量，使得容量大小刚好等于元素的个数，应用程序可以使用该操作来最小化一个ArrayList实例的存储