java进阶之ArrayList底层分析

ArrayList，线程不安全，查询速度快，增删改指定位置速度慢，可通过下标直接访问，预留空间造成浪费。默认初始化大小为10，扩容为原数组大小的1.5倍。底层结构是Object数组，代码如下：

private static final int DEFAULT_CAPACITY = 10;   //不设置数组大小，默认数组大小为10

    /**
     * Shared empty array instance used for empty instances.
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};   //默认大小为0时

    /**
     * Shared empty array instance used for default sized empty instances. We
     * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
     * first element is added.
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};  //不设置默认大小时

    /**
     * The array buffer into which the elements of the ArrayList are stored.
     * The capacity of the ArrayList is the length of this array buffer. Any
     * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
     * will be expanded to DEFAULT_CAPACITY when the first element is added.
     */
    transient Object[] elementData; // non-private to simplify nested class access  //数组

List<> list = new ArrayList<>();时，初始化代码如下：

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

List<> list = new ArrayList<>(int i);时，初始化代码如下：

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

第一个add会触发始化数组大小，代码如下：

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

private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {  //初始化的数组是否是默认无参数组，是则返回默认的数组大小
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

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

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)   //判断插入的位置是否大于数组，大于则需触发扩容
            grow(minCapacity);
    }

private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);  //扩容1.5倍，原数组大小+向右位移一位（原数组大小/2）
        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);
    }

  ArrayList的 transient  Object[] elementData;  // 被transient修饰的变量不参与序列化和反序列化。
 序列化的方式有两种：
  ①、只是实现了Serializable接口。 序列化时，调用java.io.ObjectOutputStream的defaultWriteObject方法，将对象序列化。 注意：此时transient修饰的字段，不会被序列化。 
  ②、实现了Serializable接口，同时提供了writeObject方法。 序列化时，会调用该类的writeObject方法。而不是java.io.ObjectOutputStream的defaultWriteObject方法。 注意：此时transient修饰的字段，是否会被序列化，取决于writeObject。
ArrayList的elementData不参与序列化；但是通过调用writeObject和readObject来实现序列化，代码如下：

private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException{
        // Write out element count, and any hidden stuff
        int expectedModCount = modCount;
        s.defaultWriteObject();   //默认序列化，transient不参与序列化

        // Write out size as capacity for behavioural compatibility with clone()
        s.writeInt(size);

        // Write out all elements in the proper order.
        for (int i=0; i<size; i++) {
            s.writeObject(elementData[i]);  //调用transient参数来实现序列化
        }

        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }