Arraylist部分源码分析（扩容）

Arraylist源码分析

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

RandomAccess：标志位，支持快速随机访问   get(int index)

Cloneable: 实现了clone()方法，可以实现数组的克隆

java.io.Serializable ：标示，可以序列化（接口中没有任何方法）

序列化解释：把原本在内存中的对象状态 变成可存储或传输的过程称之为序列化。序列化之后，就可以把序列化后的内容写入磁盘，或者通过网络传输到别的机器上。

i: 序列化针对对象，不针对类，所以，序列化会忽略静态变量，即序列化不保存静态变量的状态。静态成员属于类级别的，不能序列化。添加了static、transient关键字后的变量不能序列化。

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

//空数组

private static final Object[] EMPTY_ELEMENTDATA = {};

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

//保存数据的数组

transient Object[] elementData;

//数组大小

private int size;

构造方法

//无参构造方法
public ArrayList() {
//数组赋值为空（当添加元素时，数字大小才变成DEFAULT_CAPACITY）
    this.elementData = DEFAULTCAPACITY_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);
    }
}

public void trimToSize() {
    modCount++;
    if (size < elementData.length) {
        elementData = (size == 0)
          ? EMPTY_ELEMENTDATA
          : Arrays.copyOf(elementData, size);
    }
}

//将elementData数组变成size大小的数组

ArrayList扩容机制分析：

//元素的添加
public boolean add(E e) {
//确保有足够容量
    ensureCapacityInternal(size + 1);  // Increments modCount!!
//添加元素
    elementData[size++] = e;
    return true;
}

private void ensureCapacityInternal(int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
//取默认容量和minCapacity的最大值
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    ensureExplicitCapacity(minCapacity);
}

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;
//如果需要的最小容量大于elementData数组大小
    if (minCapacity - elementData.length > 0)
//扩容
        grow(minCapacity);
}

//扩容方法

private void grow(int minCapacity) {
    // 旧容量为elementData数组大小
    int oldCapacity = elementData.length;
    //新容量为旧容量的1.5倍左右（奇数不是1.5倍）
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
    //扩容之后还不够，容量直接变成所需的最小容量
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // minCapaci ty is usually close to size, so this is a win:
   //返回扩容后的新数组
    elementData = Arrays.copyOf(elementData, newCapacity);
}

Arrays.copyOf() 和 System.arrayCopy()

//用于给数组扩容（新数组复制旧数组的元素，并且大小为newLength)
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
    @SuppressWarnings("unchecked")
    T[] copy = ((Object)newType == (Object)Object[].class)
        ? (T[]) new Object[newLength]
        : (T[]) Array.newInstance(newType.getComponentType(), newLength);
    System.arraycopy(original, 0, copy, 0,
                     Math.min(original.length, newLength));
    return copy;
}

//数组的拷贝（src 源数组，srcPos源数组起始下标， dest目的数组，destPos目的数组起始下标，length要复制的数据长度）

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