ArrayList源码分析

1 关于ArrayList

ArrayList ：是实现List接口的一个实现类，底层主要是用数组来实现，相较于数组，它的强大之处就是可以实现自增长，不像数组需要指定数组的大小来创建数组。它的主要属性值如下：

 private static final int DEFAULT_CAPACITY = 10;//默认大小是10
 private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};//默认空数组，这个数组是默认返回的
private static final Object[] EMPTY_ELEMENTDATA = {};// 定义一个空的数组，当指定了ArrayList长度为0 时返回这个数组
transient Object[] elementData; // non-private to simplify nested class access//底层的数组

构造方法：

public ArrayList() {
	// 无参的构造方法 直接返回默认的数组
	//使得底层的数组等于默认的空数组
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    } 
 public ArrayList(int initialCapacity) {
 	// 有参数的构造方法，就是指定长度的ArrayList 
        if (initialCapacity > 0) {
        // 这样就直接将这个指定长度的数组赋值给原数组
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
        指定长度若是为0 则将空的数组赋值
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

2 add()

 public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
// 在指定位置插入元素
 public void add(int index, E element) {
        rangeCheckForAdd(index); // 检查下标

        ensureCapacityInternal(size + 1);  // Increments modCount!! 扩容
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);//是一个本地的方法使用C++实现
        elementData[index] = element;
        size++;
    }

由上面代码看出要添加元素需要先进行扩容，因为默认的数组是空数组，不知道大小，size 开始为 0，添加元素是 elementData[size++] = e;

3 扩容方法

// 由于一开始传入的值为size + 1 = 1 = minCapacity
 private void ensureCapacityInternal(int minCapacity) {
 	 //判断数组等于默认的空数组
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
           // default_capacity = 10 , minCapacity = 1 两者取较大的值 capacity = 10
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

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

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
        // 10 - 0 > 0
            grow(minCapacity); 调用这个容量增长的方法
    }

 private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length; //默认为0
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity; // 在默认的情况下扩容至10
        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);
    }
// Arrays.copyOf 方法
public static <T> T[] copyOf(T[] original, int newLength) {
        return (T[]) copyOf(original, newLength, original.getClass());
    }

由上面的增长代码可知grow（） 方法在空数组的情况下扩容至10，若是数组容量需要从10 再扩容 10 + 5（10 右移一位）= 15 扩容至原来的1.5倍
15 + 7 =22 扩容结束后将数组和大小传入Arrays.copyOf 方法中，返回有新长度的数组
这就是ArrayList的扩容机制，添加元素的方法，重点自增长

4 remove()

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

指定下标删除元素 还是需要依靠native方法来实现

5 get()

public E get(int index) {
        rangeCheck(index);

        return elementData(index);
    }

就是检查下标是否越界并且返回下标表示的值

6 set()

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

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

传递下标和要更改的值将这个下标的值替换为传进来的值，返回原来的值.

7ArrayList 总结

从上面的源码分析，我们可以知道，ArrayList的基本所使用方法的实现，一个很重要的方法是扩容，然后我们发现从它的指定位置添加或者删除元素的实现都会用到Array.copy 这个会用到native方法主要的实现是用到C++实现 ，所以他的增删比较困难，查找和修改值相对来说比较简单。