集合类源码——ArrayList和LinkedList（1.8）

节选自JDK1.8的ArrayList:

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

	// 默认初始容量，如果是new ArrayList<>()的话elementData默认为空，第一次add时扩容到10
	private static final int DEFAULT_CAPACITY = 10;
    
        // 加transient是为了自定义序列化方法，比如如果长度为10，只有5个元素，只需要对这5个元素序列化
	transient Object[] elementData;

	private int size;

 /**
     * The maximum size of array to allocate.
     * Some VMs reserve some header words in an array.
     * Attempts to allocate larger arrays may result in
     * OutOfMemoryError: Requested array size exceeds VM limit
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

	// modCount在AbstractList里

	public void ensureCapacity(int minCapacity) {
		int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
				// any size if not default element table
				? 0
				// larger than default for default empty table. It's already
				// supposed to be at default size.
				: DEFAULT_CAPACITY;

		if (minCapacity > minExpand) {
			ensureExplicitCapacity(minCapacity);
		}
	}

	// 实际扩容的地方
	private void grow(int minCapacity) {
		// overflow-conscious code
		int oldCapacity = elementData.length;
		// 1.5倍扩容
		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);
	}

	public int size() {
		return size;
	}

	public boolean isEmpty() {
		return size == 0;
	}


    // 入参数组长度小于size生成新数组；否则塞入数据，返回旧数组
    public <T> T[] toArray(T[] a) {
        if (a.length < size)
            // Make a new array of a's runtime type, but my contents:
            return (T[]) Arrays.copyOf(elementData, size, a.getClass());
        System.arraycopy(elementData, 0, a, 0, size);
        if (a.length > size)
            a[size] = null;
        return a;
    }

        // 返回旧值
	public E set(int index, E element) {
		rangeCheck(index);

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

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

	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;
	}
	
	//expectedModCount和modCount不一致会报ConcurrentModificationException
    //记录下一个返回的地址和之前返回的地址
	private class Itr implements Iterator<E> {
		int cursor; // index of next element to return
		int lastRet = -1; // index of last element returned; -1 if no such
		int expectedModCount = modCount;

		public boolean hasNext() {
			return cursor != size;
		}

		@SuppressWarnings("unchecked")
		public E next() {
			checkForComodification();
			int i = cursor;
			if (i >= size)
				throw new NoSuchElementException();
			Object[] elementData = ArrayList.this.elementData;
			if (i >= elementData.length)
				throw new ConcurrentModificationException();
			cursor = i + 1;
			return (E) elementData[lastRet = i];
		}


        // 不能连续remove，cursor是调用next()返回的值，而移除的是lastRet位置的值，连续移除cursor和lastRet需要前溯，和迭代器的理念相悖
		public void remove() {
			if (lastRet < 0)
				throw new IllegalStateException();
			checkForComodification();

			try {
				ArrayList.this.remove(lastRet);
				cursor = lastRet;
				lastRet = -1;
				expectedModCount = modCount;
			} catch (IndexOutOfBoundsException ex) {
				throw new ConcurrentModificationException();
			}
		}
	}
}

牢记：

(1)1.5倍扩容；

(2)数组复制底层都是System.arrayCopy()；

(3)默认容量为0，但只有第一次add才会扩容到10；

(4)迭代器中的cursor指针是调用next()的返回值，即下一个元素，remove()的是lastRet位置的值，remove()后会把lastRet置为-1，故迭代器不能连续remove()。

并行迭代器：https://blog.csdn.net/lh513828570/article/details/56673804

 

节选自JDK1.8的LinkedList:

// 实现了栈和队列的方法
public class LinkedList<E> extends AbstractSequentialList<E>
		implements List<E>, Deque<E>, Cloneable, java.io.Serializable {

	transient int size = 0;

	transient Node<E> first;

	transient Node<E> last;

	private void linkFirst(E e) {
		final Node<E> f = first;
		final Node<E> newNode = new Node<>(null, e, f);
		first = newNode;
		if (f == null)
			last = newNode;
		else
			f.prev = newNode;
		size++;
		modCount++;
	}

	// 如果只有一个节点则first = last = node
	void linkLast(E e) {
		final Node<E> l = last;
		final Node<E> newNode = new Node<>(l, e, null);
		last = newNode;
		if (l == null)
			first = newNode;
		else
			l.next = newNode;
		size++;
		modCount++;
	}

	public boolean add(E e) {
		linkLast(e);
		return true;
	}

	public E set(int index, E element) {
		checkElementIndex(index);
		Node<E> x = node(index);
		E oldVal = x.item;
		x.item = element;
		return oldVal;
	}

	public E remove(int index) {
		checkElementIndex(index);
		return unlink(node(index));
	}

	private E unlinkFirst(Node<E> f) {
		// assert f == first && f != null;
		final E element = f.item;
		final Node<E> next = f.next;
		f.item = null;
		f.next = null; // help GC
		first = next;
		if (next == null)
			last = null;
		else
			next.prev = null;
		size--;
		modCount++;
		return element;
	}
}

    LinkedList没啥好说的，注意不再实现RandomAccess。迭代器与ArrayList类似，current节点保存下一个需要遍历的节点(即调用next()的返回值)；还有lastReturned，remove()后被置空，不能连续remove()，如下图。