证明我看了源码系列：ArrayList

                          证明我看了源码系列：ArrayList

1.ArrayList简介

List是Collection的一个子接口，它表示对象的一个有序列表，意味着可以顺序访问，也可以通过索引（index）访问。可以向List中多次添加重复的元素。ArrayList是List的一个具体实现类，通过动态数组的方式来实现。

 

2.关键变/常量

private static final int DEFAULT_CAPACITY = 10;    //默认数组容量为10

transient Object[] elementData;    //

private int size;    //ArrayList的元素数量

 

3.关键方法

1.private static final Object[] EMPTY_ELEMENTDATA = {};    //对象数组构造，“真实”的空数组

2.private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};    //“虚假”的空数组：大小为默认容量

3.public ArrayList(int initialCapacity){ }    //带参构造方法，参数是给定的初始数组容量

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

关键点：如果给定的初始数组容量为0，使用ArrayList提供的方法创建对象数组。如果大于0，直接实例一个对象数组。

4.public ArrayList() { }

public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

关键点：如果不给定初始容量值，ArrayList会生成一个默认的对象数组DEFAULTCAPACITY_EMPTY_ELEMENTDATA，结合3.2理解。

5.private void grow(int minCapacity) { }    //ArrayList动态增长

private void grow(int minCapacity) {    //实现数组动态增长的方法
        // overflow-conscious code
        int oldCapacity = elementData.length;    //原容量=ArrayList包含元素数量
        int newCapacity = oldCapacity + (oldCapacity >> 1);    //新容量=原容量+(原容量>>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);    //生成新数组
    }

关键点：newCapacity = oldCapacity + (oldCapacity >> 1)，可见数组动态增长后的长度与原数组长度有关。

6.public boolean add(E e) { }    //添加元素

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 void ensureExplicitCapacity(int minCapacity) {
        modCount++;

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

关键点：参见3.5，可见当ArrayList数组已满再加入元素，触发grow（）方法。

7.public void trimToSize() { }

public void trimToSize() {
        modCount++;    //ArrayList修改次数，与线程安全有关
        if (size < elementData.length) {
            elementData = (size == 0)
              ? EMPTY_ELEMENTDATA
              : Arrays.copyOf(elementData, size);
        }
    }

关键点：参见3.4、3.5，在ArrayList数组触发grow（）方法后，数组的长度比包含元素数量大，用于删除动态增长后多余的数组容量。

eg：

ArrayList al = new ArrayList(10);
        for(int i=0;i<10;i++){
            al.add(i);
        }    //断点1
        al.add(1);    //断点2
        al.trimToSize();    //断点3
}

断点1：

断点2：

断点3：

8.public int indexOf(Object o) { }    //根据元素查索引下标

public int indexOf(Object o) {
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }


public int lastIndexOf(Object o) {
        if (o == null) {
            for (int i = size-1; i >= 0; i--)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = size-1; i >= 0; i--)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

关键点：可见是通过数组遍历找元素，lastIndexOf()是逆序遍历，contains()是通过indexOf()来判断是否存在。