Java集合(二)ArrayList详解

（1）ArrayList简介

java.lang.Object
   ↳     java.util.AbstractCollection<E>
         ↳     java.util.AbstractList<E>
               ↳     java.util.ArrayList<E>

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

ArrayList动态数组，线程不安全，单线程中使用，多线程使用vector或者copyonwritearraylist
ArrayList继承AbstractList，实现了List，提供了添加删除修改遍历等
ArrayList实现了RandomAccess提供了随机访问的功能
ArrayList实现了Cloneable接口，即覆盖了函数clone,能够被克隆
ArrayList实现了Serializable接口，支持序列化，能通过序列化去传输

ArrayList中两个重要的对象：elementData 和 size。
1）elementDate:保存添加到ArrayList中的元素，是一个动态数组，我们通过构造函数可以指定初始化容量，默认容量10，如果需要增长容量，增长规则：新的容量=“(原始容量x3)/2 + 1”
2）size是动态数组的实际大小

（2）ArrayList重点源码分析

ArrayList源码分析(JDk6)

public class ArrayList<E> extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable
    {
    private static final long serialVersionUID = 8683452581122892189L;
    //保存ArrayList中数据的数组
    private transient Object[] elementData;
    //ArrayList的实际数据的数量
    private int size;

    //带容量大小的构造函数
    public ArrayList(int initialCapacity) {
    super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
    this.elementData = new Object[initialCapacity];
    }

    //默认构造函数，初始化容量值为10
    public ArrayList() {
    this(10);
    }

    //创建一个包含collection的ArrayList  
    public ArrayList(Collection<? extends E> c) {
    elementData = c.toArray();
    size = elementData.length;
    // c.toArray might (incorrectly) not return Object[] (see 6260652)
    if (elementData.getClass() != Object[].class)
        elementData = Arrays.copyOf(elementData, size, Object[].class);
    }

   //当前容量值=实际元素个数
    public void trimToSize() {
    modCount++;
    int oldCapacity = elementData.length;
    if (size < oldCapacity) {
            elementData = Arrays.copyOf(elementData, size);
    }
    }

   //确定ArrayList的容量，如果ArrayList的容量不足以容纳当前的全部元素，扩容。新的容量=（原始容量*3）/2+1
    public void ensureCapacity(int minCapacity) {
    modCount++;
    int oldCapacity = elementData.length;
    if (minCapacity > oldCapacity) {
        Object oldData[] = elementData;
        int newCapacity = (oldCapacity * 3)/2 + 1;
            if (newCapacity < minCapacity)
        newCapacity = minCapacity;
            // minCapacity is usually close to size, so this is a win:
            elementData = Arrays.copyOf(elementData, newCapacity);
    }
    }

    //返回当前容量值
    public int size() {
    return size;
    }

    //判断ArrayList是否为空
    public boolean isEmpty() {
    return size == 0;
    }

    //判断ArrayList是否包含某元素
    public boolean contains(Object o) {
    return indexOf(o) >= 0;
    }

    //正向查找是否包含某元素，可以看出ArrayList允许为空元素
    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;
    }

    //反向查找是否包含某元素
    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;
    }

    //克隆Arraylist
    public Object clone() {
    try {
        ArrayList<E> v = (ArrayList<E>) 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();
    }
    }

    //返回ArrayList的Object数组
    public Object[] toArray() {
        return Arrays.copyOf(elementData, size);
    }

    //返回ArrayList的模板数组，如果a的大小<ArrayList的个数，则新建T[],大小为ArrayList的大小，同时将ArrayList全部拷贝到T中
    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;
    }

    //获取index位置的元素值
    public E get(int index) {
    RangeCheck(index);

    return (E) elementData[index];
    }

    //设置index位置的元素值为E
    public E set(int index, E element) {
    RangeCheck(index);

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

    //将元素e添加到ArrayList的最后
    public boolean add(E e) {
    ensureCapacity(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
    }

    //将元素E添加到ArrayList中的index位置
    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] = element;
    size++;
    }

    //移除index的某元素
    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[--size] = null; // Let gc do its work

    return oldValue;
    }

    //移除ArrayList中的某个对象
    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;
    }

    //快速移除某个位置元素，可以看到快速移除和普通移除的差别在于，不会检测index是否在ArrayList范围内，同时返回值为空
    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
    }
    //清除ArrayList中的全部元素，设置为null,说明允许重复
    public void clear() {
    modCount++;

    // Let gc do its work
    for (int i = 0; i < size; i++)
        elementData[i] = null;

    size = 0;
    }

    //将集合C添加到ArrayList中
    public boolean addAll(Collection<? extends E> c) {
    Object[] a = c.toArray();
        int numNew = a.length;
    ensureCapacity(size + numNew);  // Increments modCount
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
    return numNew != 0;
    }

    //将集合C添加到ArrayList中的某个Index位置之后
    public boolean addAll(int index, Collection<? extends E> c) {
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(
        "Index: " + index + ", Size: " + size);

    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacity(size + numNew);  // Increments modCount

    int numMoved = size - index;
    if (numMoved > 0)
        System.arraycopy(elementData, index, elementData, index + numNew,
                 numMoved);

        System.arraycopy(a, 0, elementData, index, numNew);
    size += numNew;
    return numNew != 0;
    }

   //移除区间范围的全部元素
    protected void removeRange(int fromIndex, int toIndex) {
    modCount++;
    int numMoved = size - toIndex;
        System.arraycopy(elementData, toIndex, elementData, fromIndex,
                         numMoved);

    // Let gc do its work
    int newSize = size - (toIndex-fromIndex);
    while (size != newSize)
        elementData[--size] = null;
    }

   //检测index是否在ArrayList范围内
    private void RangeCheck(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(
        "Index: "+index+", Size: "+size);
    }

   //将ArrayList的容量，所有元素值都写入到输出流中
    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();
        }

    }

   //将流中的数据读出
    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();
    }
}

ArrayList源码分析(JDk8)

jdk8中的ArrayList在jdk6的基础上做了很大的改变，但是基本思路是一致的，同样有add,remove,addAll等方法。但是在扩容上做了很大的处理，保证了高效的分配空间，更加合理的处理了ArrayList为空的情况。这里我只列出改动比较大的方法，没有做出全部对比。

//默认容量大小
private static final int DEFAULT_CAPACITY = 10;
//空数组常量
private static final Object[] EMPTY_ELEMENTDATA = {};
//默认空数组容量
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//存放元素的数组,transient无法自动序列化，数组内存储的元素其实是一个引用，单单序列化一个引用没有意义，反序列化后这些无法在指向原来的对象
transient Object[] elementData;
//数组中的元素个数
private int size;
//数组的最大上限
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;  

//带容量大小的构造函数，当容量值为0分配空的数组常量，而JDK6中不会考虑数组为空的情况
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);
    }
}
//空构造函数，不在是创建容量为10的，而是默认的空数组
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
//创建一个包含collection的ArrayList
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;
    }
}
//同jdk6中的方法
public void trimToSize() {
    modCount++;
    if (size < elementData.length) {
        elementData = (size == 0)
          ? EMPTY_ELEMENTDATA
          : Arrays.copyOf(elementData, size);
    }
}
//扩容
 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);
    }
}
//扩容检测，检测数组大小是否为0，为0，就默认扩容大小10；当数组大小大于当前数组大小时，才进行扩容
private void ensureCapacityInternal(int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }

    ensureExplicitCapacity(minCapacity);
}
//扩容
private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}
//扩容是真正调用的方法，扩容策略：新容量=原容量大小的1.5倍
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);
}

思考： （1）remove方法中，为什么将数组对应的元素设置为Null？

在remove方法中已经将元素的数量-1了，ArrayList认为该对象已经被移除，应该被jvm回收。
但是对于jvm来说，该对象仍然保留在数组中。ArrayList持有这个对象的引用，
在JVM发生GC的时候，这个对象是不会被jvm回收，这样会造成内存泄露    

（2）查找元素的方法中（比如indexOf），为什么需要对元素进行null值判断

判断对象是否相等，有两个方面。1.对象的存储地址 2.对象的值  
==：判断两个对象的地址是否相等  
equals:判断两个对象的值是否相等  
对元素进行null值判断，应该是为了效率考虑，如果是Null的话直接比较地址，而是非空，通过equals比较

（3）jdk6和jdk8中对于ArrayList的扩容方式： 

JDK8：新容量 = 原容量*1.5（先进行大小检测，如果检测大小是0，那么扩容大小是10）
JDK6：新容量 = （原容量*3）/2+1

（3）ArrayList遍历方式

通过随机访问效率最高，使用迭代器效率最低 1）通过迭代器Iterator遍历

Iterator iter = list.iterator();
while(iter.hasNext()){
    System.out.print(iter.next());
}  

2）通过随机访问，通过索引值遍历

Integer value = null;
int size = list.size();
for (int i=0; i<size; i++) {
    value = (Integer)list.get(i);        
}  

3）for循环遍历

for(int i = 0; i < stringList.size();i++){
        System.out.print(stringList.get(i));
    }