ArrayList源码分析

 ArrayList 类结构如下

ArrayList继承AbstractList,实现了list,RandomAccess,Cloneable,Serializable，支持随机访问、克隆和序列化。

RandomAccess是一个标记接口，表示支持随机访问，ArrayList底层是用数组实现了，数组可以通过index随机访问元素。Jdk中Collections 类有binarySearch方法，查询List集合中某个元素的索引值。如果集合实现了RandomAccess接口，就支持采用二分查找，否则使用迭代器。

    int binarySearch(List<? extends Comparable<? super T>> list, T key) {
        if (list instanceof RandomAccess || list.size()<BINARYSEARCH_THRESHOLD)
            //使用二分查找
            return Collections.indexedBinarySearch(list, key);
        else
            //使用迭代器，顺序遍历
            return Collections.iteratorBinarySearch(list, key);
    }

ArrayList成员变量如下：

//默认的数组容量
private static final int DEFAULT_CAPACITY = 10;
//无参构造函数的空数组会用DEFAULTCAPACITY_EMPTY_ELEMENTDATA赋值，有参构造函数的空数组会用EMPTY_ELEMENTDATA赋值
private static final Object[] EMPTY_ELEMENTDATA = {};
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//存放数据的数组，用transient修饰表示不参与序列化
transient Object[] elementData;
//当前容量
private int size;
//最大数组容量
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
//数组被修改的次数
protected transient int modCount = 0;

 ArrayList底层使用数组来实现，transient 修饰的变量不能被序列化。ArrayList 中数组是按照1.5倍的机制扩容，所以每个elementData会留有一定的余量。序列化时并不需要将整个数组对象保存到磁盘当中。当ArrayList 进行序列化时，会使用内部的writeObject方法将elementData中存储的有效数据进行持久化。

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

ArrayList 添加数据与扩容机制

    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) {
            //如果数组容量为空，返回默认值DEFAULT_CAPACITY与minCapacity的最大值
            //无参构造时，返回默认的10
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }
    private void ensureExplicitCapacity(int minCapacity) {
        //记录数组元素被修改的次数
        modCount++;

        // overflow-conscious code
        //如果添加数据需要的最小容量，大于当前数组容量，需要进行扩容
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    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;
        //扩容后超过最大容量，返回最大容量，当newCapacity为负数时，抛出异常
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        //旧数组元素复制到新数组，elementData引用指向新数组
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

总结：ArrayList底层使用数组来实现，数组的初始大小为10，当容量不足时，扩容为原来的1.5倍，并将旧数组元素复制到新数组当中。

ArrayList 优点与缺点

优点：基于数组，在数组中搜索和读取数据是很快的。因此 ArrayList 获取数据的时间复杂度是O(1)。

缺点：添加、删除时该元素后面的所有元素都要移动，所以添加/删除数据效率不高；另外每次达到阈值需要扩容，这个操作比较影响效率。

ArrayList fast-fail 快速失败机制

fail-fast，它是Java集合的一种错误检测机制。某个线程在对collection进行迭代时，不允许其他线程对该collection进行结构上的修改。

每次调用ArrayList的add和remove方法都会使的modCount自增。Itr是ArrayList的内部类，每当调用iterator()初始化内部类Itr时，expectedModCount会初始化为当前的modCount。在迭代的过程中会判断expectedModCount是否等于modCount，如果不等于，说明

在迭代的过程中，可能其他线程修改了对ArrayList进行了操作，从而修改了modCount的值。当迭代器检测到并发时，就会抛出异常。

    public Iterator<E> iterator() {
        return new Itr();
    }    
    private class Itr implements Iterator<E> {
        int cursor;       // index of next element to return
        int lastRet = -1; // index of last element returned; -1 if no such
        //Itr类被初始化时，expectedModCount会初始化为modCount
        int expectedModCount = modCount;

        Itr() {}

        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();
            }
        }
        略....
    }

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

ArrayList在for循环中增删元素问题

    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);
        elementData[--size] = null; // clear to let GC do its work

        return oldValue;
    }

remove 方法中会调用System.arraycopy 移动数组中的元素，如果在普通for循环中删除元素，由于元素索引位置的移动，遍历出现问题

public static void main(String[] args) {
    List<Integer> list = new ArrayList<Integer>();
    list.add(1);
    list.add(2);
    list.add(3);
    list.add(4);
    list.add(5);
    for (int i = 0; i < list.size(); i++) {
        System.out.println(list.get(i));
        if (list.get(i) == 1) {
           list.remove(i);
           //需要手动修改指针，才能解决问题
           //i--
        }
    }
    //不手动修改指针元素2不会输出

}

在增强for循环当中调用add或remove方法会抛出异常

增强for内部使用的是迭代器，当迭代器被初始化时，内部的expectedModCount也会被初始化，如果在循环中调用add或remove方法，会改变modCount的值，当迭代器检测到expectedModCount不等于modCount时，会抛出异常。

因此要在循环中删除ArrayList 元素时需要使用迭代器。

ArrayList线程不安全的原因

1、出现覆盖

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        //可以解析为：
        //elementData[size] = e;
        //size++;
        return true;
    }

 size++ 不是原子性操作，比如当两个线程同时读取到size为9时，线程一执行到elementData[size] = e时挂起，线程二执行elementData[size] = e，这样就发生了覆盖。之后线程一将size增加到10，线程二将size增加到11

2、越界异常

数组容量默认为10，假设当前已经存储了9个元素。当线程一执行完ensureCapacityInternal(size + 1)，发现不需要扩容，之后挂起。

线程二调到add添加元素，在索引位9的位置添加一个元素，此时，数组容量已经满了，size=10.

线程一被唤醒，由于之前没有扩容，数组容量已经满了，elementData[size++] = e 抛出越界异常。