学步园

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

 public void add(int index, E element) {
	if (index > size || index < 0)
	    throw new IndexOutOfBoundsException(
		"Index: "+index+", Size: "+size);
	ensureCapacity(size+1);  // Increments modCount!!
	System.arraycopy(elementData, index, elementData, index + 1,
			 size - index); //elementData[index,size) --> elementData[index+1,size+1)
	elementData[index] = element;
	size++;
 }

ensureCapacity扩容方法：开始前有对modCount修改操作，实现fast-fail迭代

public void ensureCapacity(int minCapacity) {
        modCount++;
        int oldCapacity = elementData.length;
        if (minCapacity > oldCapacity) {
            Object oldData[] = elementData;
            int newCapacity = (oldCapacity * 3)/2 + 1; //0.5倍扩容策略
                if (newCapacity < minCapacity)
            newCapacity = minCapacity;
                // minCapacity is usually close to size, so this is a win:
                elementData = Arrays.copyOf(elementData, newCapacity);
        }
}

remove方法，移动index+1及其后面元素，并将最后一个元素设置为null，帮助GC回收

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

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

fastRemove是私有方法没有返回old value

private void fastRemove(int index) {
        modCount++;
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // Let gc do its work
}

重写readObject和writeObject进行序列化和反序列化，保证只会序列化实际大小的数组避免空间浪费，可以看到writeObject的时候有fast fail判断

private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
	// Read in size, and any hidden stuff
	s.defaultReadObject();
        // Read in array length and allocate array
        int arrayLength = s.readInt();
        Object[] a = elementData = new Object[arrayLength];
	// Read in all elements in the proper order.
	for (int i=0; i<size; i++)
            a[i] = s.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();
        // Write out array length
        s.writeInt(elementData.length);
	// 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();
        }
}

迭代器实现

public boolean hasNext() {
       return cursor != size();
}
public E next() {
       checkForComodification();
       try {
		E next = get(cursor);
		lastRet = cursor++;
		return next;
	 } catch (IndexOutOfBoundsException e) {
		checkForComodification();
		throw new NoSuchElementException();
	}
}

remove方法

public void remove() {
	    if (lastRet == -1)
		throw new IllegalStateException();
            checkForComodification();
	    try {
		AbstractList.this.remove(lastRet);
		if (lastRet < cursor)
		    cursor--;
		lastRet = -1;
		expectedModCount = modCount;
	    } catch (IndexOutOfBoundsException e) {
		throw new ConcurrentModificationException();
	    }
}

-next和remove方法前都需要调用checkForComodification检验容器是否被修改，若被修改则抛出ConcurrentModificationException

ListItr(int index) {
      cursor = index;
}

previous和next方法设置lastRet不同，next方法是cursor未加1之前的值，而previous是cursor减1以后的值

public boolean hasPrevious() {
	    return cursor != 0;
	}
	public E previous() {
		checkForComodification();
        try {
                int i = cursor - 1;
                E previous = get(i);
                lastRet = cursor = i;
                return previous;
        } catch (IndexOutOfBoundsException e) {
                checkForComodification();
                throw new NoSuchElementException();
        }
}

set方法是在lastRet处修改该元素的值，向前遍历一次previous则为cursor-1，向后遍历一次则为cursor

public void set(E e) {
	    if (lastRet == -1)
		throw new IllegalStateException();
            checkForComodification();
	    try {
		AbstractList.this.set(lastRet, e);
		expectedModCount = modCount;
	    } catch (IndexOutOfBoundsException ex) {
		throw new ConcurrentModificationException();
	    }
}

add方法在当前cursor位置添加，并将cusor加1

public void add(E e) {
        checkForComodification();
	try {
	    	AbstractList.this.add(cursor++, e);
	    	lastRet = -1;
	    	expectedModCount = modCount;
	} catch (IndexOutOfBoundsException ex) {
	    	throw new ConcurrentModificationException();
	}
}

总结

参考