JDK源码分析之ArrayList（一）

ArrayList源码分析(一)

ArrayList是集合类中比较常用的类，其本质就是动态数组，用MSDN中的说法，就是Array的复杂版本，它提供了动态的增加和减少元素的方法，灵活的设置数组的大小等好处，了解其底层源码能让我们更好更深入的使用它。

ArrayList属性主要就是当前数组长度size，以及存放数组的对象elementData数组，除此之外还有一个经常用到的属性就是从AbstractList继承过来的modCount属性，代表ArrayList集合的修改次数。

咱们从jdk1.8源码中一个个方法进行分析，来对arraylist进行了解。

1.容器的默认大小为10

private static final int DEFAULT_CAPACITY = 10;

2.它的底层其实是一个Object类型的数组

transient Object[] elementData;

private int size;

Object[] elementData是一个buffer数组，用来存储ArrayList的数据，该数组的大小表示ArrayList的容量，而size属性表示的是ArrayList里边存储元素的个数。

3.数组最大长度

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

根据integer类型中的最大值来设置的数组最大长度（@Native public static final int
MAX_VALUE = 0x7fffffff;）

ArrayList的三种构造方法：

①无参构造：

多个ArrayList实例共享的static属性，一个空数组的实例，使用ArrayList的无参构造函数创建ArrayList实例的时候，直接使用DEFAULTCAPACITY_EMPTY_ELEMENTDATA给底层数组elementData赋值

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

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

②有参int构造：

若有大于0的int类型则赋值object对象数组，若创建一个容量为0的ArrayList时，直接将层数组elementData赋值为另外一个static属性EMPTY_ELEMENTDATA

private static final Object[] EMPTY_ELEMENTDATA = {};

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

③有参collection构造：

将Collection转成数组对象，赋值给elementData空数组（这里称为浅拷贝），如果数组还是为空，就赋值为另外一个static属性EMPTY_ELEMENTDATA；

如果有值并且是对象数组类型（toArray有可能不能正确返回一个对象类型数组），就使用Arrays.copyOf重新赋值成对象类型数组（这里称为深拷贝）。

 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)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        // replace with empty array.
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

add方法

add的方法有两个，一个是带一个参数的，一个是带两个参数的

一、带一个参数的add：

确保数组在使用长度（size）加1的情况下，足够存下 下一个数据。

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

①ensureCapacityInternal

确保添加的元素有地方存储，当第一次添加元素的时候this.size+1 的值是1，所以第一次添加的时候会将当前elementData数组的长度变为默认值10（DEFAULT_CAPACITY）：

private void ensureCapacityInternal(int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }

    ensureExplicitCapacity(minCapacity);
}

②ensureExplicitCapacity

修改次数modCount 标识自增1，如果当前数组已使用长度（size）加1后的大于当前的数组长度，则调用grow方法。

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

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

③grow

用于增长数组，数组容量扩增到Integer.MAX_VALUE-8的时候，就会开始限制数组扩充，超过Integer.MAX_VALUE的时候，抛内存溢出异常
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);
}

最后再将数据存入最后一位，并有一个boolean类型的返回值；两个参数的add方法没有返回值

elementData[size++] = e;
return true;

---

二、带两个参数的add方法

public void add(int index, E element) {
    rangeCheckForAdd(index);

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

这个方法其实和上面的add类似，该方法可以按照元素的位置，指定位置插入元素，具体的执行逻辑如下：

首先检查传入坐标的准确性，有错的话就报数组越界错误。

private void rangeCheckForAdd(int index) {
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

经过与上面add方法一样的过程：

确保有足够的容量之后，使用System.arraycopy 将需要插入的位置（index）后面的元素统统往后移动一位。

将新的数据内容存放到数组的指定位置（index）上

System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
elementData[index] = element;
size++;

该方法没有返回值

get方法

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

    return elementData(index);
}

先会检查index坐标是否有效，然后直接返回对应值

set方法

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

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

确保set的位置小于当前数组的长度（size）并且大于0，获取指定位置（index）元素，然后放到oldValue存放，将需要设置的元素放到指定的位置（index）上，然后将原来位置上的元素oldValue返回给用户。

contains方法

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

调用indexOf方法，遍历数组中的每一个元素作对比，如果找到对于的元素，则返回true，没有找到则返回false。

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

往后ArrayList的第二部分介绍remove、clear、sublist、trimToSize、iterator、Arrays.copyOf等方法。