之前看了一下《兰亭风雨》的集合源码分析,原地址为:http://blog.csdn.net/ns_code/article/details/35568011,发现和jdk1.8略微有点不同,因此参照他的博客格式,自己一点点的分析了一下jdk1.8的源码,然而发现1.8里添加了很多的方法,因此这里只写常用的,其实只要知道数据结构怎么变动的,其他的都是大同小异。
ArrayList是基于数组实现的,是一个动态数组,其容量能自动增长,类似于C语言中的动态申请内存,动态增长内存。
ArrayList不是线程安全的,只能用在单线程环境下,多线程环境下可以考虑用Collections.synchronizedList(List l)函数返回一个线程安全的ArrayList类,也可以使用concurrent并发包下的CopyOnWriteArrayList类。
ArrayList实现了Serializable接口,因此它支持序列化,能够通过序列化传输,实现了RandomAccess接口,支持快速随机访问,实际上就是通过下标序号进行快速访问,实现了Cloneable接口,能被克隆。
ArrayList的源码如下(加入了比较详细的注释):
package java.util; public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable { //序列版本号 private static final long serialVersionUID = 8683452581122892189L; //默认ArrayList的容量 private static final int DEFAULT_CAPACITY = 10; //空元素的数组,主义里面是Object类型的 private static final Object[] EMPTY_ELEMENTDATA = {}; //默认容量空元素的数组 private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; //ArrayList基于该数组实现,用该数组保存数据,里面元素是Object,瞬时的,非序列化 transient Object[] elementData; // non-private to simplify nested class access //ArrayList中实际数据的数量 private int size; //ArrayList带容量大小的构造函数 public ArrayList(int initialCapacity) { //如果传入的容量大于0,就按要求建一个Object数组 if (initialCapacity > 0) { this.elementData = new Object[initialCapacity]; //如果传入的容量等于0,返回一个空元素数组 } else if (initialCapacity == 0) { this.elementData = EMPTY_ELEMENTDATA; } else { //如果传入的容量小雨0,返回一个非法参数异常 throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity); } } //创建一个空参构造函数,这个才是数组的元素为空 public ArrayList() { this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; } //创建一个包含Collection的ArrayList public ArrayList(Collection<? extends E> c) { //先将集合元素转为数组,因为ArrayList维护的就是一个数组 elementData = c.toArray(); //如果里面的元素个数不为0, if ((size = elementData.length) != 0) { //看数组里的元素是不是Object,如果不是就转为Object if (elementData.getClass() != Object[].class) elementData = Arrays.copyOf(elementData, size, Object[].class); } else { //如果里面元素为0个,那么直接一个空元素数组 this.elementData = EMPTY_ELEMENTDATA; } } //将集合的当前容量设为实际元素的个数 public void trimToSize() { modCount++; //看实际个数是否小于容器的长度 if (size < elementData.length) { //判断元素个数等于0?,如果等于直接返回空元素数组,否则copy一份指定大小的数组 elementData = (size == 0) ? EMPTY_ELEMENTDATA : Arrays.copyOf(elementData, size); } } //确认ArrayList的容量 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); } } //返回ArrayList里的元素个数 public int size() { return size; } //判断ArrayList是否为空 public boolean isEmpty() { return size == 0; } //判断ArrayList是否包含某个元素(接受Object类型的) public boolean contains(Object o) { //其实就是调用了indexOf,如果没有找到,必然返回为false return indexOf(o) >= 0; } //正向查找,返回元素的索引值 public int indexOf(Object o) { //把null单独提出来,因为null不能用equals方法判断 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) { //同理要把null单独拿出来判断 //此外由于是数组,所以初始化坐标为size-1 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; } //克隆函数 public Object clone() { try { ArrayList<?> v = (ArrayList<?>) super.clone(); //将当前ArrayList的全部元素拷贝到v中 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); } } //返回ArrayList的Object数组 public Object[] toArray() { 就是用Arrays copy了一份一模一样的 return Arrays.copyOf(elementData, size); } //返回ArrayList元素组成的数组,这个返回的是泛型,不是Object数组 public <T> T[] toArray(T[] a) { //如果数组a的大小 < ArrayList的元素个数,则呈现建一个T[]数组,数组大小是ArrayList的元素个数,并将并将“ArrayList”全部拷贝到新数组中 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位置的元素值,返回是E public E get(int index) { //检查范围,其实就是看index>size不,如果大于就抛异常 rangeCheck(index); return elementData(index); } //设置index位置的元素 public E set(int index, E element) { //先检查一下范围 rangeCheck(index); //先把老的值保存一下,用于返回 E oldValue = elementData(index); elementData[index] = element; return oldValue; } //添加元素 public boolean add(E e) { //先确认一下容量,使容量设置为size+1 ensureCapacityInternal(size + 1); // Increments modCount!! //将元素添加到ArrayList的末尾 elementData[size++] = e; return true; } //从某个元素位置开始添加元素 public void add(int index, E element) { //先检查范围 rangeCheckForAdd(index); //确认数组的容量 ensureCapacityInternal(size + 1); // Increments modCount!! //arraycopy(Object src, int srcPos,Objectm dest,int destPos,int length),从指定源数组中复制一个数组,复制从指定的位置开始,到目标数组的指定位置结 //束。其实就是将从index开始到后面的数组向后移了一位 System.arraycopy(elementData, index, elementData, index + 1,size - index); elementData[index] = element; //记得数据个数+1 size++; } //删除ArrayList指定位置的元素 public E remove(int index) { rangeCheck(index); modCount++; E oldValue = elementData(index); //确定index后面的数据长度 int numMoved = size - index - 1; if (numMoved > 0) System.arraycopy(elementData, index+1, elementData, index,numMoved); elementData[--size] = null; // clear to let GC do its work return oldValue; } //删除ArrayList的指定元素 public boolean remove(Object o) { if (o == null) {//先将null单独判断 for (int index = 0; index < size; index++) if (elementData[index] == null) { //其实就是将找到的index后面的数据向前移 fastRemove(index); return true; } } else {//遍历ArrayList,找到到指定的元素 for (int index = 0; index < size; index++) if (o.equals(elementData[index])) { fastRemove(index); return true; } } return false; } 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; // clear to let GC do its work } //清空ArrayList,将全部元素设为null public void clear() { modCount++; for (int i = 0; i < size; i++) elementData[i] = null; //size设为0 size = 0; } //添加进一个集合 public boolean addAll(Collection<? extends E> c) { //先将集合变为数组 Object[] a = c.toArray(); int numNew = a.length;//集合的长度 //确认新ArrayList的数据个数 ensureCapacityInternal(size + numNew); // Increments modCount System.arraycopy(a, 0, elementData, size, numNew); size += numNew; //numNew == 0返回false,相当于没添加 return numNew != 0; } //在指定位置添加一个结合,其实就是System.arraycopy,哪里第二个参数为index public boolean addAll(int index, Collection<? extends E> c) { rangeCheckForAdd(index); Object[] a = c.toArray(); int numNew = a.length; ensureCapacityInternal(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; } //删除fromIndex到toIndex之间的全部元素 protected void removeRange(int fromIndex, int toIndex) { modCount++; int numMoved = size - toIndex; System.arraycopy(elementData, toIndex, elementData, fromIndex,numMoved); // clear to let GC do its work //把后边空出来的位置设为null int newSize = size - (toIndex-fromIndex); for (int i = newSize; i < size; i++) { elementData[i] = null; } size = newSize; } //范围检查,每次操作index时,都要检查一下,看是否超出元素个数范围,如果超过就直接抛异常,不用做下一步操作 private void rangeCheck(int index) { if (index >= size) throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); }