java的ArrayList分析

源码分析

具体关系：

1. 我们平时常用需要掌握的：
   ArrayList，LinkedList，HashMap，HashSet。。。

2. List，Set，Map对比

接口	子接口	是否有序	是否允许元素重复
Collection		否
List	ArrayList	否	是
	LinkedList	否	是
	Vector	否	是
Set	AbstractSet	否	否
	HashSet	否	否
	TreeSet	是（用二叉排序树）	否
Map	AbstractMap	否	使用key-value来映射和存储数据，key必须唯一，value可以重复
	HashMap		否
	TreeMap	是（用二叉排序树）	使用key-value来映射和存储数据，key必须唯一，value可以重复

ArrayList详解

内部主要是数组实现
1. 内部变量

    /**
     * 初始化容量
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * 用于空实例的共享空数组实例
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

    /**
     * 共享的空数组实例，用于默认大小的空实例。我们将其与EMPTY_ELEMENTDATA区别开来，以了解添加第一个元素时需要充气多少。
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    /**
     * 存储ArrayList的元素的数组缓冲区。 ArrayList的容量是此数组缓冲区的长度。添加第一个元素时，任何具有elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA 的空ArrayList将被扩展为DEFAULT_CAPACITY。
     */
    transient Object[] elementData; // non-private to simplify nested class access

    /**
     * ArrayList的大小（它包含的元素数）
     *
     * @serial
     */
    private int size;

2. 构造函数

// 构造一个具有指定初始容量的空列表。
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);
        }
    }


// 构造一个初始容量为10的空列表
public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

// 构造一个包含指定*集合的元素的列表，其顺序由集合的迭代器返回。 
public ArrayList(Collection<? extends E> c) {
        Object[] a = c.toArray();
        if ((size = a.length) != 0) {
            if (c.getClass() == ArrayList.class) {
                elementData = a;
            } else {
                elementData = Arrays.copyOf(a, size, Object[].class);
            }
        } else {
            // replace with empty array.
            elementData = EMPTY_ELEMENTDATA;
        }
    }

3. add 方法

// 将指定的元素追加到此列表的末尾。
public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // 增加modCount！
        elementData[size++] = e;
        return true;
    }

/ **
* 在列表中特定的位置新增特定的元素，移动当前在该位置的元素（如果有）并且右边的任何后续元素（将其索引添加一个）
*/
public void add(int index, E element) {
        rangeCheckForAdd(index); // 判断

        ensureCapacityInternal(size + 1);  // 增加modCount！
        System.arraycopy(elementData, index, elementData, index + 1, size - index);
        elementData[index] = element;
        size++;
    }

// add和addAll使用的rangeCheck版本
  private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

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

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

// 增加容量以确保它至少可以容纳最小容量参数指定的元素数。
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);
    }

通过源码我们可以看出：
Arraylist在添加元素的时候，首先进行的是范围检查，防止其传入的参数小于0或者超过数组的size大小，再是和默认分配的大小值进行比较，如果大于默认大小就要进行扩容。扩容的时候首先把旧数组的大小提升1.5倍，成为新数组的大小值。同时也可以看到Arrylist的大小边界是Interger的最大值，这个数字是很大的：2147483647，也就是它的最大值是这么多，这个值足以我们程序员平常进行使用！在检查完毕和扩容完毕之后，就是要进行数组的拷贝了，我们开看一下System.arrayCopy()方法的源码：

public static native void arraycopy(Object src,  int  srcPos, Object dest,  int destPos, int length);

中可以看出，它是native修饰的，也就是说它是一个引用本地其他语言的代码库（windows就是.dll库）的方法，具体的源码我们不深究了，这里解释一下它的参数，src：你要从哪个数组复制，srcpos:要复制的位置起点 dest：要复制要哪个数组，destPos：要复制到的数组起始位置 lengh:复制的长度

System.arraycopy(elementData, index, elementData, index + 1,  size - index);

4. remove方法
我们看romove方法首先还是进行范围检查，然后用elementData()方法去找到指定数组元素中的值，再用size-index-1转为numMoved，接着进行再次自我复制。然后把size-1甚至设置为null。这样这个数组中元素就是null了。

public E remove(int index) {//根据指定位置移除元素
        rangeCheck(index);//范围检查

        modCount++;//修改次数+1
        E oldValue = elementData(index);//根据数组元素的位置找到旧值

        int numMoved = size - index - 1;
        if (numMoved > 0)//判断是否大于0
            System.arraycopy(elementData, index+1, elementData, index,numMoved);
        elementData[--size] = null; // 

        return oldValue;//返回旧值
    }

// 从此列表中删除第一次出现的指定元素，如果存在，则将其删除。如果列表不包含该元素，则不变。
public boolean remove(Object o) {
        if (o == null) {
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);
                    return true;
                }
        } else {
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }

// 专用remove方法，跳过边界检查，并且不返回删除的值。
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
    }