带着问题学习ArrayList源码

前言

ArrayList是List接口的实现类，底层数据结构是动态数组，所以支持随机访问，但是增加和删除的时间复杂度为O(N)。

• ArrayList中elementData为什么要用transient修饰？
• ArrayList插入元素的过程？
• ArrayList如何解决大数据插入耗时问题？

继承关系

ArrayList实现的接口

• RandomAccess接口：支持随机访问的标识接口。
• Serializable接口：支持序列化操作。
• Cloneable接口：重写clone()方法需要实现Cloneable接口，不然会报异常。

成员变量

private static final int DEFAULT_CAPACITY = 10;

transient Object[] elementData;

private int size;

• DEFAULT_CAPACITY：ArrayList默认的容量为10。
• elementData：transient修饰的对象数组。
• size：数组中元素的个数。

Q：为什么elementData要用transient修饰？

因为ArrayList实现了Serializable接口，所以是支持可序列化的，transient的作用是不希望elementData被序列化，然后ArrayList重写了writeObject()方法：

private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException{
        // Write out element count, and any hidden stuff
        int expectedModCount = modCount;
        s.defaultWriteObject();
        // 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]);
        }
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }

每次序列化的时候先调用defaultWriteObject()序列化ArrayList中非transient修饰的元素，然后遍历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);
        }
    }

因为ArrayList的频繁扩容会导致性能降低，所以推荐实例化ArrayList的时候指定容量。

不指定容量的构造函数

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

ArrayList的无参构造函数，数组elementData初试为空，只有第一次add元素的时候，才进行初始化，这种方式叫懒初始化。

传入一个集合的构造函数

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

首先将传入的集合通过toArray()方法转化为数组，然后判断数组的大小是否为空，不为空就将数组元素复制到elementData中，如果为空，则elementData初始化为空数组。

主要方法

add(E e)方法

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

1. 首先通过ensureCapacityInternal(size+1)判断容量是否足够。
2. 然后直接在数组末尾赋值。

其中确保容量足够的方法ensureCapacityInternal(size+1)如下

 private void ensureCapacityInternal(int minCapacity) {
 	ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
 }
 private void ensureExplicitCapacity(int minCapacity) {
 	modCount++;
    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
    	grow(minCapacity);
}

如果数组的容量不够，则需要调用grow()方法进行扩容

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

ArrayList扩容后的容量是旧容量的1.5倍，如果扩容1.5倍之后，容量还不够，就会直接扩充为需要的容量大小。

Q：如何解决ArrayList大数据插入耗时问题？

如果有大量数据插入ArrayList中，有可能引发ArrayList频繁地扩容，我们知道扩容操作要的复制元素，所以耗时很长，一般解决的办法有两种

• 通过指定容量的方式来构造ArrayList，但是这种方式需要提前预知数据量。
• 可以插入大量元素之前，通过ensureExplicitCapacity()方法提前判断容量是否足够，相当于提前进行了扩容，相当于减少了ensureCapacityInternal()方法的调用次数，提高了性能。

add(int index, E element)

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(int index, E element)是在指定下标下插入元素

1. 判断index的范围是否正确。
2. 判断容量是否足够。
3. 将下标位置后面的元素往后挪动一位。
4. 在index位置处插入元素。

remove(int index)

public E remove(int index) {
	rangeCheck(index);
	modCount++;
	E oldValue = elementData(index);
	int numMoved = size - index - 1;
	if (numMoved > 0)
    	System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
	elementData[--size] = null; // clear to let GC do its work
	return oldValue;
}

E remove(int index)删除指定下标下的元素，并且返回被删除元素

1. 判断index的范围是否正确。
2. modCount++。
3. 记录被删除元素。
4. 将下标位置后面的元素都往前挪动一位。
5. 将数组原来最后一个元素的位置置为空。
6. 返回被删除元素。

remove(Object o)

public boolean remove(Object o) {
        if (o == null) {
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);
                    return true;
                }
        } else {
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }

boolean remove(Object o)删除指定元素，如果删除成功返回true，否则返回false，这里如果待删除的元素为空，使用==来比较，如果不为空，使用equals()方法来比较，因为如果对于String这些重写过equals()方法的引用类型来说，就是值比较，而不是引用比较。