java.util.ArrayList随笔 java7 vs java8

参数保留

//VMs reserve some header words in an array
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
private static final Object[] EMPTY_ELEMENTDATA = {}
private static final int DEFAULT_CAPACITY = 10;

解析

从字面看是因为环境不同导致JVM编译器在数组中放入了 header words
所以，数组最大长度MAX_ARRAY_SIZE不是 Integer.MAX_VALUE 而被定义为 Integer.MAX_VALUE-8
EMPTY_ELEMENTDATA用于初始化，，数组增长时的判断与取值
DEFAULT_CAPACITY 默认初始化大小10
参数新增

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

解析

DEFAULTCAPACITY_EMPTY_ELEMENTDATA java8新增用于无参时的初始化

参数调整

transient Object[] elementData; 
// non-private to simplify nested class access

解析

很明显 只剔除了private关键字，elementData仍为不可序列化数组

其他知识点

继承自 AbstractList

AbstractList定义为

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E>

由此可知 ArrayList 具备 List 和 Collection 的特性，可按索引或按对象增加或删除，按索引增加删除是List的特性。

System.arraycopy和 Arrays.copyOf

初始化和转换数组使用 Arrays.copyOf
add和remove相关方法使用 System.arraycopy居多

equals

未重写此方法，使用父类AbstractList的方法

public boolean equals(Object o) {
	if (o == this)
		return true;
	if (!(o instanceof List))
		return false;

	ListIterator<E> e1 = listIterator();
	ListIterator<?> e2 = ((List<?>) o).listIterator();
	while (e1.hasNext() && e2.hasNext()) {
		E o1 = e1.next();
		Object o2 = e2.next();
		if (!(o1==null ? o2==null : o1.equals(o2)))
			return false;
	}
	return !(e1.hasNext() || e2.hasNext());
}

hashCode

未重写此方法，使用父类AbstractList的方法

public int hashCode() {
	int hashCode = 1;
	for (E e : this)
		hashCode = 31*hashCode + (e==null ? 0 : e.hashCode());
	return hashCode;
}

clone

public Object clone() {
	try {
		ArrayList<?> v = (ArrayList<?>) super.clone();
		v.elementData = Arrays.copyOf(elementData, size);
		v.modCount = 0;
		return v;
	} catch (CloneNotSupportedException e) {
		// this shouldn't happen, since we are Cloneable
		throw new InternalError(e);
	}
}

Itr

增加默认无参构造器

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;

	**Itr() {}//java7没有** 
	...
	...
}

据分析是因为 ListItr子类调用了super，按照继承原则，如果子类显示调用父类构造器，而父类无此构造器则会报错

    private class ListItr extends Itr implements ListIterator<E> {
        ListItr(int index) {
            **super();**//就是这里
            cursor = index;
        }

总结

ArrayList的访问方法没有用synchronized关键字，因此可以确定是非线程安全的容器，无增长系数，默认初始化容量为10，当然实际参数个数size要小于等于此值， elementData 也有length的属性。
为什么说实际长度是size？
看第一段代码

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

再看第二段

    public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            **this.elementData = new Object[initialCapacity];**//初始化是 initialCapacity
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

注释的语句应该都能明白了，数组length=initialCapacity，size在add和remove时会自增或自减，因此 size才是有效的数组长度。