Java集合分析--ArrayList

转自：https://blog.csdn.net/panweiwei1994/article/details/76760238

ArrayList可以总结出以下几点：

底层：ArrayList是List接口的大小可变数组的实现。
是否允许null：ArrayList允许null元素。
时间复杂度：size、isEmpty、get、set、iterator和listIterator方法都以固定时间运行，时间复杂度为O(1)。add和remove方法需要O(n)时间。与用于LinkedList实现的常数因子相比，此实现的常数因子较低。
容量：ArrayList的容量可以自动增长。
是否同步：ArrayList不是同步的。
迭代器：ArrayList的iterator和listIterator方法返回的迭代器是fail-fast的。

1. 先来看看ArrayList的定义：

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

2. 代码分析:
/**
 * 初始化默认容量。
 */
private static final int DEFAULT_CAPACITY = 10;

/**
 * 指定该ArrayList容量为0时，返回该空数组。
 */
private static final Object[] EMPTY_ELEMENTDATA = {};

/**
 * 当调用无参构造方法，返回的是该数组。刚创建一个ArrayList 时，其内数据量为0。
 * 它与EMPTY_ELEMENTDATA的区别就是：该数组是默认返回的，而后者是在用户指定容量为0时返回。
 */
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

/**
 * 保存添加到ArrayList中的元素。
 * ArrayList的容量就是该数组的长度。
 * 该值为DEFAULTCAPACITY_EMPTY_ELEMENTDATA 时，当第一次添加元素进入ArrayList中时，数组将扩容值DEFAULT_CAPACITY。
 * 被标记为transient，在对象被序列化的时候不会被序列化。
 */
transient Object[] elementData; // non-private to simplify nested class access

/**
 * ArrayList的实际大小（数组包含的元素个数）。
 * @serial
 */
private int size;

思考：elementData被标记为transient，那么它的序列化和反序列化是如何实现的呢？
ArrayList自定义了它的序列化和反序列化方式。详情请查看writeObject(java.io.ObjectOutputStream s)和readObject(java.io.ObjectOutputStream s)方法。

ArrayList实现了java.io.Serializable接口，但是这个接口是一个空的接口，又是怎样保证实现了它这个接口才能进行序列化和反序列化呢？这时要从ObjectOutputStream的writeObject方法开始寻找原因：

//ObjectOutputStream的writeObject方法
public final void writeObject(Object obj) throws IOException {
    if (enableOverride) {
        writeObjectOverride(obj);
        return;
    }
    try {
        writeObject0(obj, false);   //!!!!!
    } catch (IOException ex) {
        if (depth == 0) {
            writeFatalException(ex);
        }
        throw ex;
    }
}

private void writeObject0(Object obj, boolean unshared) throws IOException{
    // remaining cases
    if (obj instanceof String) {
        writeString((String) obj, unshared);
    } else if (cl.isArray()) {
        writeArray(obj, desc, unshared);
    } else if (obj instanceof Enum) {
        writeEnum((Enum) obj, desc, unshared);
    } else if (obj instanceof Serializable) {
        writeOrdinaryObject(obj, desc, unshared);
    } else {
        if (extendedDebugInfo) {
            throw new NotSerializableException(
                cl.getName() + "\n" + debugInfoStack.toString());
        } else {
            throw new NotSerializableException(cl.getName());
        }
    }
}

writeObject0方法中在进行序列化操作的时候会判断要被序列化的类是否是String、Enum、Array和Serializable类型，如果不是则直接抛出NotSerializableException（未序列化异常）
如果对象是Serializable类型，则调用writeOrdinaryObject方法，在这个方法中有一个写序列化数据的方法 writeSerialData(obj, desc);这个方法中有一个 invokeWriteObject(obj, this)方法，可以通过对象输出流写入对象，这样就将Serializable和序列化与反序列化联系起来了
void invokeWriteObject(Object obj, ObjectOutputStream out) throws IOException, UnsupportedOperationException

ArrayList实际上是动态数组，每次在放满以后自动增长设定的长度值，如果数组自动增长长度设为100，而实际只放了一个元素，那就会序列化99个null元素，那么为了防止一个包含大量空对象的数组被序列化，为了优化存储，所以，ArrayList使用transient来声明存放对象的数组elementData[]，
但是，作为一个集合，在序列化过程中还必须保证其中的元素可以被持久化下来，所以，通过重写writeObject 和 readObject方法的方式把其中的元素保留下来。
writeObject方法把elementData数组中的元素遍历的保存到输出流（ObjectOutputStream）中。
readObject方法从输入流（ObjectInputStream）中读出对象并保存赋值到elementData数组中。
//ArrayList中的writeObject和readObject方法参与了序列化和反序列化
 private void writeObject(java.io.ObjectOutputStream s)  throws java.io.IOException{}
 private void readObject(java.io.ObjectInputStream s)  throws java.io.IOException, ClassNotFoundException {}

如何自定义的序列化和反序列化策略？？
如果答：可以通过在被序列化的类中增加writeObject 和 readObject方法？？？
那么又有一个问题，虽然ArrayList中写了writeObject 和 readObject 方法，但是这两个方法并没有显示的被调用啊。那么如果一个类中包含writeObject 和 readObject 方法，那么这两个方法是怎么被调用的呢?
答：在使用ObjectOutputStream的writeObject方法和ObjectInputStream的readObject方法时，会通过反射reflect的方式调用。

 

构造方法
接下来，看ArrayList提供的构造方法。ArrayList提供了三种构造方法。

ArrayList(int initialCapacity)：构造一个指定容量为capacity的空ArrayList。
ArrayList()：构造一个初始容量为 10 的空列表。
ArrayList(Collection<? extends E> c)：构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。
ArrayList( int initialCapacity)

 /**
 * 构造一个指定初始化容量为capacity的空ArrayList。
 * @param  initialCapacity  ArrayList的指定初始化容量
 * @throws IllegalArgumentException  如果ArrayList的指定初始化容量为负。
 */
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);
    }
}

ArrayList()

/**
 * 构造一个初始容量为 10 的空列表。
 */
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

ArrayList(Collection<? extends E> c)

/**
 * 构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。
 *
 * @param c 其元素将放置在此列表中的 collection
 * @throws NullPointerException 如果指定的 collection 为 null
 */
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;
    }
}

核心方法
ArrayList有以下核心方法

方法名    时间复杂度
get(int index)    O(1)
add(E e)    O(1)
add(add(int index, E element))    O(n)
remove(int index)    O(n)
set(int index, E element)    O(1)
get( int index)
/**
 * 返回list中索引为index的元素
 *
 * @param  index 需要返回的元素的索引
 * @return list中索引为index的元素
 * @throws IndexOutOfBoundsException 如果索引超出size
 */
public E get(int index) {
    //越界检查
    rangeCheck(index);
    //返回索引为index的元素
    return elementData(index);
}

/**
 * 越界检查。
 * 检查给出的索引index是否越界。
 * 如果越界，抛出运行时异常。
 * 这个方法并不检查index是否合法。比如是否为负数。
 * 如果给出的索引index>=size，抛出一个越界异常
 */
private void rangeCheck(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

/**
 * 返回索引为index的元素
 */
@SuppressWarnings("unchecked")
E elementData(int index) {
    return (E) elementData[index];
}

从代码中可以看到，因为ArrayList底层是数组，所以它的get方法非常简单，先是判断一下有没有越界，之后就直接通过数组下标来获取元素。get方法的时间复杂度是O(1)。

add(E e)
/**
 * 添加元素到list末尾.
 *
 * @param e 被添加的元素
 * @return true
 */
public boolean add(E e) {
    //确认list容量，如果不够，容量加1。注意：只加1，保证资源不被浪费，然后顺着调用链， 发现ensureExplicitCapacity中对modCount进行了加1操作
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

add方法每次都会使modCount加1，这个属性是怎么来的呢？ 继承自AbstractList， 父类AbstractList中有一个属性modCount， 定义如下：

protected transient int modCount = 0;

 

从源码中可以看到，add(E e)有两个步骤：

空间检查，如果有需要进行扩容
插入元素
空间检查和扩容的介绍在下面。

空间的问题解决后，插入过程就显得非常简单。

扩容-ensureCapacity等方法
/**
* 增加ArrayList容量。
* 
* @param   minCapacity   想要的最小容量
*/
public void ensureCapacity(int minCapacity) {
    // 如果elementData等于DEFAULTCAPACITY_EMPTY_ELEMENTDATA，最小扩容量为DEFAULT_CAPACITY，否则为0
    int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)? 0: DEFAULT_CAPACITY;
    //如果想要的最小容量大于最小扩容量，则使用想要的最小容量。
    if (minCapacity > minExpand) {
        ensureExplicitCapacity(minCapacity);
    }
}
/**
* 数组容量检查，不够时则进行扩容，只供类内部使用。
* 
* @param minCapacity    想要的最小容量
*/
private void ensureCapacityInternal(int minCapacity) {
    // 若elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA，则取minCapacity为DEFAULT_CAPACITY和参数minCapacity之间的最大值
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }

    ensureExplicitCapacity(minCapacity);
}
/**
* 数组容量检查，不够时则进行扩容，只供类内部使用
* 
* @param minCapacity 想要的最小容量
*/
private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // 确保指定的最小容量 > 数组缓冲区当前的长度  
    if (minCapacity - elementData.length > 0)
        //扩容
        grow(minCapacity);
}

/**
 * 分派给arrays的最大容量
 * 为什么要减去8呢？
 * 因为某些VM会在数组中保留一些头字，尝试分配这个最大存储容量，可能会导致array容量大于VM的limit，最终导致OutOfMemoryError。
 */
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

/**
* 扩容，保证ArrayList至少能存储minCapacity个元素
* 第一次扩容，逻辑为newCapacity = oldCapacity + (oldCapacity >> 1);即在原有的容量基础上增加一半。第一次扩容后，如果容量还是小于minCapacity，就将容量扩充为minCapacity。
* 
* @param minCapacity 想要的最小容量
*/
private void grow(int minCapacity) {
    // 获取当前数组的容量
    int oldCapacity = elementData.length;
    // 扩容。新的容量=当前容量+当前容量/2.即将当前容量增加一半。
    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);
}
/**
* 进行大容量分配
*/
private static int hugeCapacity(int minCapacity) {
    //如果minCapacity<0，抛出异常
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    //如果想要的容量大于MAX_ARRAY_SIZE，则分配Integer.MAX_VALUE，否则分配MAX_ARRAY_SIZE
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}

看完了代码，可以对扩容方法总结如下：

进行空间检查，决定是否进行扩容，以及确定最少需要的容量
如果确定扩容，就执行grow(int minCapacity)，minCapacity为最少需要的容量
第一次扩容，逻辑为newCapacity = oldCapacity + (oldCapacity >> 1);即在原有的容量基础上增加一半。
第一次扩容后，如果容量还是小于minCapacity，就将容量扩充为minCapacity。
对扩容后的容量进行判断，如果大于允许的最大容量MAX_ARRAY_SIZE，则将容量再次调整为MAX_ARRAY_SIZE。至此扩容操作结束。
add( int index, E element)
/**
 * 在制定位置插入元素。当前位置的元素和index之后的元素向后移一位
 *
 * @param index 即将插入元素的位置
 * @param element 即将插入的元素
 * @throws IndexOutOfBoundsException 如果索引超出size
 */
public void add(int index, E element) {
    //越界检查
    rangeCheckForAdd(index);
    //确认list容量，如果不够，容量加1。注意：只加1，保证资源不被浪费
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    // 对数组进行复制处理，目的就是空出index的位置插入element，并将index后的元素位移一个位置
    System.arraycopy(elementData, index, elementData, index + 1,size - index);
    //将指定的index位置赋值为element
    elementData[index] = element;
    //实际容量+1
    size++;
}

从源码中可以看到，add(E e)有三个步骤：

越界检查
空间检查，如果有需要进行扩容
插入元素
越界检查很简单

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

空间检查和扩容的介绍在上面。

空间的问题解决后，插入过程就显得非常简单。

add(int index, E e)需要先对元素进行移动，然后完成插入操作，也就意味着该方法有着线性的时间复杂度，即O(n)。

remove( int index)
/**
 * 删除list中位置为指定索引index的元素
 * 索引之后的元素向左移一位
 *
 * @param index 被删除元素的索引
 * @return 被删除的元素
 * @throws IndexOutOfBoundsException 如果参数指定索引index>=size，抛出一个越界异常
 */
public E remove(int index) {
    //检查索引是否越界。如果参数指定索引index>=size，抛出一个越界异常
    rangeCheck(index);
    //结构性修改次数+1
    modCount++;
    //记录索引为inde处的元素
    E oldValue = elementData(index);

    // 删除指定元素后，需要左移的元素个数
    int numMoved = size - index - 1;
    //如果有需要左移的元素，就移动（移动后，该删除的元素就已经被覆盖了）
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    // size减一，然后将索引为size-1处的元素置为null。为了让GC起作用，必须显式的为最后一个位置赋null值
    elementData[--size] = null; // clear to let GC do its work

    //返回被删除的元素
    return oldValue;
}

/**
 * 越界检查。
 * 检查给出的索引index是否越界。
 * 如果越界，抛出运行时异常。
 * 这个方法并不检查index是否合法。比如是否为负数。
 * 如果给出的索引index>=size，抛出一个越界异常
 */
private void rangeCheck(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

看完代码后，可以将ArrayList删除指定索引的元素的步骤总结为

检查索引是否越界。如果参数指定索引index>=size，抛出一个越界异常
将索引大于index的元素左移一位（左移后，该删除的元素就被覆盖了，相当于被删除了）。
将索引为size-1处的元素置为null（为了让GC起作用）。
注意：为了让GC起作用，必须显式的为最后一个位置赋null值。上面代码中如果不手动赋null值，除非对应的位置被其他元素覆盖，否则原来的对象就一直不会被回收。

set( int index, E element)
/**
 * 替换指定索引的元素
 *
 * @param 被替换元素的索引
 * @param element 即将替换到指定索引的元素
 * @return 返回被替换的元素
 * @throws IndexOutOfBoundsException 如果参数指定索引index>=size，抛出一个越界异常
 */
public E set(int index, E element) {
    //检查索引是否越界。如果参数指定索引index>=size，抛出一个越界异常
    rangeCheck(index);

    //记录被替换的元素
    E oldValue = elementData(index);
    //替换元素
    elementData[index] = element;
    //返回被替换的元素
    return oldValue;
}

用到的设计模式
迭代器模式