ArrayList源码解读

ArrayList源代码底层是使用数组实现，默认的初始空间是10

成员变量

    // 默认空间
    private static final int DEFAULT_CAPACITY = 10;
    // 默认空数组
    private static final Object[] EMPTY_ELEMENTDATA = {};
    // 默认空数组
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    // 数组元素
    transient Object[] elementData; // non-private to simplify nested class access
    // 数组元素大小
    private int size;

构造方法

// 带初始容器大小得构造方法    
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);
        }
    }
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    // 集合复制
    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                // 将给定得集合数据，复制到ArrayList
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

Arrays.copyOf(T[] org, int newLength) // 数组拷贝,有多个参数，一般只用2个

params1: 复制得原数组

params2: 新的数组长度 eg: 4

返回数据 一个新的数组，元素个数是4个，数组a个数大于4时，取前4个，小于4时，不足4个的补0

add()

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

add方法很简单，难理解的是ensureCapacityInternal()这个扩容方法

ensureCapacityInternal(int size)

    private void ensureCapacityInternal(int minCapacity) {
        //如果是数组是空数组, 数组容器大小变成默认容器大小
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        // 扩容
        ensureExplicitCapacity(minCapacity);
    }

ensureExplicitCapacity(int size)

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

        // overflow-conscious code
        // minCapacity是我们需要的数组长度，如果需要的长度，比原数组长度大，就说明要扩容了
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

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

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

这个方法其实很简单,但是有一个坑

if (o.equals(elementData[i]))
return i;

这个使用equals进行比较，但是用的是Object对象的equals，不是集合元素自己的，Object的equals只比较了引用地址是不是相同，如果想要比较元素里面属性是否相同，得重写equals方法

其他得方法都比较简单!以上方法细节需要掌握