JDK源码之ArrayList和Vector

一、ArrayList源码阅读
arrayList: 可变大小的list接口的实现
1.1 重要参数

//list默认容量
private static final int DEFAULT_CAPACITY = 10;
//空实例
private static final Object[] EMPTY_ELEMENTDATA = {};
//共享的空array数组实例，可以在添加元素后大小自动扩展至默认DEFAULT_CAPACITY
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
// ArrayList的底层实现数组
transient Object[] elementData; 

1.2 构造器
看构造器的实现可以发现，ArrayList通过elementData这个数组示例来实现，ArrayList底层是数组。

// 构造指定容量的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
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
// 构造包含默认元素的ArrayList
public ArrayList(Collection<? extends E> c) {
    elementData = c.toArray();
    if ((size = elementData.length) != 0) {
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

1.3 方法
trimToSize()：该方法用于将arraylist的null所占的空间收回，是为了节约内存空间。
如下示例，初始化一个容量为12的arrayList，放入10个元素，可以发现第10和11位为null，通过使用该方法瘦身后，容量变为了和元素个数一致的大小，为10，节省了空间。

Contains()判断是否包含某元素，indexOf和lastIndexOf分别返回元素第一次出现和最后一次出现的索引。

// 获取List的大小
public int size() { return size;}
// 根据List大小判断arrayList实例是否为空
public boolean isEmpty() { return size == 0;}
// contains方法判断是否包含某一元素，可判断null，可以看出是用循环实现的
public boolean contains(Object o) {
    return indexOf(o) >= 0;
}
public int indexOf(Object o) {
    if (o == null) {
        for (int i = 0; i < size; i++)
            if (elementData[i]==null)
                return i;
    } else { 
	for (int i = 0; i < size; i++)
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;}
// 返回某一元素的索引，和contains的实现方法类似
public int lastIndexOf(Object o) {
    if (o == null) {
        for (int i = size-1; i >= 0; i--)
            if (elementData[i]==null)
                return i;
    } else {
        for (int i = size-1; i >= 0; i--)
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;}

Clear()值置为null，size置0，实际上空间并没有回收

public void clear() {
    modCount++;
    // clear to let GC do its work
    for (int i = 0; i < size; i++)
        elementData[i] = null;
    size = 0;
}

Arraycopy：
该方法是add, addAll, remove,removeAll, retainAll的底层实现方法

//将src从srcPos位置开始的length个元素复制到dest的destPos位置后
public static native void arraycopy(Object src,  int  srcPos,
                                    Object dest, int destPos,
                                    int length);

ensureCapacity(int minCapacity)：扩容arrayList的底层数组容量
该方法用于扩展arrayList的容量，若参数值大于数组的1.5倍，则扩展到参数组大小，若小于数组的1.5倍，则数组扩容为原大小的1.5倍。核心代码在grow中。

public void ensureCapacity(int minCapacity) {
    int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
        ? 0 : DEFAULT_CAPACITY;
    if (minCapacity > minExpand) {
        ensureExplicitCapacity(minCapacity);
    }
}
private void ensureExplicitCapacity(int minCapacity) {
    modCount++;
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}
private void grow(int minCapacity) {
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    elementData = Arrays.copyOf(elementData, newCapacity);
}
private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}

modCount： 在《ArrayList使用不当带来的ConcurrentModificationException及其五种避免方案》中有提到，因为modeCount和expectedModCount不相等。阅读源码可知，modCount表示list结构修改的次数，一般指涉及到size的修改。

深拷贝和浅拷贝：clone方法是浅拷贝；
从下面的代码打印可以看出，clone创建了一个全新的arrayList对象，但是list中存储的对象clone后只拷贝了其地址引用，所以更改对象中的属性后，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);}}

我们可以通过下面的使用观察一下clone()方法

ArrayList arrList1 = new ArrayList<>(12);
arrList1.addAll(x11);
User user = new User();
user.setAge(1);
arrList1.add(user);
ArrayList x12 = (ArrayList) arrList1.clone();
System.out.println("arrList1:" + arrList1.toString());
System.out.println("x12:" + x12.toString());
System.out.println("x12和arrList1地址：" + (x12 == arrList1));
System.out.println("x12和arrList1中存的对象地址：" + (x12.get(10) == arrList1.get(10)));
user.setAge(2);
System.out.println("修改arrList1中的User对象后 x12:" + x12.toString());

此外，还有一些简单方法：Iterator(),listIterator(),listIterator(int index)

二、Vector阅读
Vector在jdk中被定义为可变的array.
2.1 属性

//底层数组
protected Object[] elementData;
// 元素数量
protected int elementCount;
// 每次扩容增加的数量
protected int capacityIncrement;

2.2 构造器

public Vector(int initialCapacity, int capacityIncrement) {
    super();
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    this.elementData = new Object[initialCapacity];
    this.capacityIncrement = capacityIncrement;
}
public Vector(int initialCapacity) {
    this(initialCapacity, 0);
}
public Vector() {
    this(10);
}
public Vector(Collection<? extends E> c) {
    elementData = c.toArray();
    elementCount = elementData.length;
    // c.toArray might (incorrectly) not return Object[] (see 6260652)
    if (elementData.getClass() != Object[].class)
        elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
}

2.3 Vector是线程安全的

Vector: vector的方法使用了synchronized，因此效率比arrayList低
public synchronized void trimToSize() {
    modCount++;
    int oldCapacity = elementData.length;
    if (elementCount < oldCapacity) {
        elementData = Arrays.copyOf(elementData, elementCount);
    }
}
ArrayList:
public void trimToSize() {
    modCount++;
    if (size < elementData.length) {
        elementData = (size == 0)
          ? EMPTY_ELEMENTDATA: Arrays.copyOf(elementData, size);}
}

2.4 Vector方法
vector方法大部分和arrayList保持一致，只是加了synchronized关键字，因此，我们观察一些不同于arrayList的方法。

// 将vector转为枚举类型
public Enumeration<E> elements() {
    return new Enumeration<E>() {
        int count = 0;
        public boolean hasMoreElements() {
            return count < elementCount; }
        public E nextElement() {
            synchronized (Vector.this) {
                if (count < elementCount) {
                    return elementData(count++);}}
            throw new NoSuchElementException("Vector Enumeration"); }
    };
}

集合容量扩展：相比arrayList扩展至1.5倍原数组，vector扩展至2倍原数组

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                     capacityIncrement : oldCapacity);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    elementData = Arrays.copyOf(elementData, newCapacity);}

vector和arrayList区分总结：

1. Vector是线程安全的，arraylist不是
2. vector容量自然扩展是扩展为原数组的2倍，arrayList是扩展为原数组的1.5倍
3. 由于第一点，因此也导致vector效率更低；

但是vector和arrayList在操作数组进行增删改查上速度慢，这也促成了LinkedList的出现。下一部分我们将阅读LinkedList源码。

Tips: 新建一个arrayList对象应该用ArrayList还是List去引用对象？？他们分别对我们的使用带来哪些影响？？
Answer: 这个问题实质是应该使用实现类还是用接口去引用对象。对于不涉及类的特定方法的使用，最好使用接口去引用，便于后续更改数据类型，如arrayList改为vector。对于调用特定方法的情况或者为了增加易读性，最好使用实现类去引用。