ArrayList源码学习
一、 类与成员变量：
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
ArrayList继承自AbstractList抽象类，实现了List<E>、RandomAccess、Cloneable、Serializable接口。
其中：
实现RandomAccess接口的List可以通过简单的for循环来访问数据比使用iterator访问来的高效快速。
实现Cloneable接口的类的对象允许被克隆。同时该类需要重写Object类的clone方法。
实现Serializable接口，即采用了Java默认的序列化机制。
private static final long serialVersionUID = 8683452581122892189L;
serialVersionUID 是源类的哈希值。有了serialVersionUID之后，那么如果序列化的类已经保存了在本地中，中途你更改了类后，serialVersionUID变了，那么反序列化的时候就不会变成原始的类了，还会抛异常，主要就是用于版本控制。
*序列化的作用是能转化成Byte流，然后又能反序列化成原始的类。能在网络进行传输，也可以保存在磁盘中。
private transient Object[] elementData; private int size;
transient关键字的作用：在采用Java默认的序列化机制的时候，被该关键字修饰的属性不会被序列化。但是Object[] elementData属性是ArrayList的底层数据结构，在网络传输中一定需要将其序列化，之后使用的时候还需要反序列化，那不采用Java默认的序列化机制，那采用什么呢？直接翻到源码的最下边有两个方法，发现ArrayList自己实现了序列化和反序列化的方法writeObject()、readObject()。
/** * Save the state of the <tt>ArrayList</tt> instance to a stream (that * is, serialize it). * * @serialData The length of the array backing the <tt>ArrayList</tt> * instance is emitted (int), followed by all of its elements * (each an <tt>Object</tt>) in the proper order. */ 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(); } } /** * Reconstitute the <tt>ArrayList</tt> instance from a stream (that is, * deserialize it). */ 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(); }
二、构造：
public ArrayList(int initialCapacity) { //父类的构造器，调用子类构造时必须先调用父类构造，通常为隐式调用。若父类没有无 参构造，则必须显示调用。 super(); if (initialCapacity < 0) throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity); this.elementData = new Object[initialCapacity]; } public ArrayList() { this(10); } 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); }
当我们执行 new ArrayList<String>()时，会调用无参构造，实际是调用ArrayList(int initialCapacity)创建了一个容量为10的对象。
当我们执行 new ArrayList<String>(2)时，会调用ArrayList(int initialCapacity)，创建了一个容量为2的对象。
**在实际使用中，如果可以估算出所需的大小，建议调用ArrayList(int initialCapacity)构造，如估计需要放置18个元素到容器，就可以new ArrayList<String>(20)，这样会减少数组扩容时引起的效率下降。
当我们执行 new ArrayList<String>(Collection c)时，实际是将其他Collection容器转为ArrayList对象。
三、操作ArrayList
1、添加
1.1 数组扩容：
public void ensureCapacity(int minCapacity) { modCount++; int oldCapacity = elementData.length; //获取当前数组长度。 if (minCapacity > oldCapacity) { //当传入的参数大于当前长度时进行扩容。 Object oldData[] = elementData; //获取当前数组。 int newCapacity = (oldCapacity * 3)/2 + 1; //将当前数组扩容1.5倍 if (newCapacity < minCapacity) //如果新扩容的长度仍然小于传入参数，则将传入参数作为新的数组长度。 newCapacity = minCapacity; // minCapacity is usually close to size, so this is a win: elementData = Arrays.copyOf(elementData, newCapacity); //将当前数组的内容和新的数组长度作为参数，复制新的数组。 } }
1.2 add(E e) 添加一个元素到容器：
public boolean add(E e) { ensureCapacity(size + 1); //保证数组有足够的空间可以容纳新元素。 elementData[size++] = e; //将新元素存储到当前数组使用长度+1的位置。 return true; }
1.3 add(int index, E element) 添加一个元素到容器的指定位置：
public void add(int index, E element) { //判断指定的位置是否属于当前数组的使用长度内，超过使用长度则没有指定的必要都是添加到数组的尾部的。 if (index > size || index < 0) throw new IndexOutOfBoundsException( "Index: "+index+", Size: "+size); ensureCapacity(size+1); //保证数组有足够的空间可以容纳新元素。 // System.arraycopy（被复制的数组，被复制数组的起始位置，复制的数组，从第几位开始，复制的长度） System.arraycopy(elementData, index, elementData, index + 1, size - index); //将index及其后边的所有的元素整块后移，空出 index位置。 elementData[index] = element;//将元素放入指定位置。 size++;//当前数组长度+1 }
1.4 addAll(Collection<? extends E> c) 添加一个Collection对象到容器：
/** * 将c全部加入elementData */ public boolean addAll(Collection<? extends E> c) { Object[] a = c.toArray();//将c集合转化为对象数组a int numNew = a.length;//获取a对象数组的容量 ensureCapacity(size + numNew);//确保对象数组elementData有足够的容量，可以将新加入的a对象数组加进去 System.arraycopy(a, 0, elementData, size, numNew);//将对象数组a拷贝到elementData中去 size += numNew;//重新设置elementData中已加入的元素的个数 return numNew != 0;//若加入的是空集合则返回false }
2、删除
2.1 fastRemove(int index)容器删除元素
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;//将最后一个元素设为null，在下次gc的时候就会回收掉了 }
2.2 remove(int index)删除指定位置元素
private void RangeCheck(int index) { if (index >= size) throw new IndexOutOfBoundsException("Index: "+index+",Size: "+size); } public E remove(int index) { RangeCheck(index);//检查删除的位置存不存在元素 E oldValue = (E) elementData[index];//找出要被删除的元素 //这个作者封装了fastRemove（int index）方法，但是不知道为什么没有调用。。。可能是忘了吧 //modeCount++; //int numMoved = size - index - 1; //if (numMoved > 0) // System.arraycopy(elementData, index+1, elementData, index,numMoved); //elementData[--size] = null; fastRemove(index); return oldValue; }
2.3 remove(Object o) 删除第一个出现的元素 o
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; }
3、修改
3.1 set(int index, E element) 修改指定位置元素
public E set(int index, E element) { RangeCheck(index);//检查索引范围 E oldValue = (E) elementData[index];//旧值 elementData[index] = element;//该位置替换为新值 return oldValue;//返回旧值 }
4、查询、获取
4.1 get(int index) 获取指定位置对象
public E get(int index) { RangeCheck(index);//检查索引范围 return (E) elementData[index];//返回元素，并将Object转型为E }
4.2 indexOf(Object o) 获取指定元素的位置
public int indexOf(Object o) {//获取第一个出现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) {//获取最后一个出现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; }
4.3 contains(Object o) 查询容器中是否包含某元素
public boolean contains(Object o) { return indexOf(o) >= 0; }
总结：
1、使用ArrayList容器时可以先估算一下需要存储的元素数量，使用new ArrayList(int i)构造来创建对象，可以减少数组扩容过程的引起的效率下降。
2、remove(Object o)需要遍历数组，remove(int index)不需要，只需要判断索引符合范围即可，所以，通常：后者效率更高。
3、可以通过简单的for循环来访问数据比使用iterator访问来的高效快速。
