ArrayList源码分析

首先来总结一下，ArrayList的一些特点：

　　1.arraylist本质上就是一个elementData数组，它允许对元素进行快速随机访问，可以存放null值；

　　2.arraylist区别于数组的地方在于能够自动扩展大小，其中关键就是grow() 方法，每次扩充后数组为原来数组的1.5倍；

　　3.arraylist由于本质是数组，所以它在数据的查询方面会很快，而在插入删除方面，性能会下降很多，要移动很多数据才能达到应有的效果；

　　4.arraylist中的removeAll(collection c)和clear() 的区别就是removeAll可以删除批量指定的元素，而clear是全部删除集合中的元素；

　　5.arraylist实现了RandomAccess，所以在遍历时推荐使用for循环；

　　6.arraylist是线程不安全的；

一、继承结构和层次关系

　　由图可以看出，ArrayList 继承于AbstractList；AbstractList 继承于AbstractCollection；所有类都继承于Object。

1.为什么要先继承AbstractList，让AbstractList先实现List<E>，而不是让ArrayList直接实现List<E>？

　　接口中全都是抽象的方法，而抽象类中可以有抽象方法，还可以有具体的实现方法，让AbstractList实现接口中一些通用的方法，而具体的类，如ArrayList就继承这个AbstractList类，拿到一些通用的方法，然后自己再实现一些自己特有的方法。

2.ArrayList实现了那些接口？

　　List<E>接口

　　RandomAccedd接口：是一个标记性接口，作用是用来快速随机存取。若实现了该接口，使用普通的for循环来遍历，性能更高，例如arraylist。而没有实现该方法的接口，使用iterator来迭代，这样性能更高，例如LinkedList。

　　Cloneable接口：实现了该接口，就可以使用Object.Clone()方法。

　　Serializable接口：实现该序列化接口，表明该类可以被序列化。

二、构造方法

1.无参构造方法

//这里就说明了默认会给10的大小，所以说一开始arrayList的容量是10.
　    //ArrayList中储存数据的其实就是一个数组，这个数组就是elementData，在123行定义的 private transient Object[] elementData;
　　 public ArrayList() {　　
            super();        //调用父类中的无参构造方法，父类中的是个空的构造方法
            this.elementData = EMPTY_ELEMENTDATA;    //EMPTY_ELEMENTDATA：是个空的Object[]， 将elementData初始化，elementData也是个Object[]类型。空的Object[]会给默认大小10。
        }

2.有参构造方法1

public ArrayList(int initialCapacity) {
        super(); //父类中空的构造方法
        if (initialCapacity < 0)    //判断如果自定义大小的容量小于0，则报非法数据异常
            throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);
            this.elementData = new Object[initialCapacity]; //将自定义的容量大小当成初始化elementData的大小
    }

3.有参构造方法2（不常用）

//我还有一个Collection<Student>、由于这个Student继承了Person，那么根据这个构造方法，我就可以把这个Collection<Student>转换为ArrayList<Sudent>这就是这个构造方法的作用 
     public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();    //转换为数组
        size = elementData.length;   //数组中的数据个数
        if (elementData.getClass() != Object[].class) //每个集合的toarray()的实现方法不一样，所以需要判断一下，如果不是Object[].class类型，那么就需要使用ArrayList中的方法去改造一下。
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    }

三、常用方法

1.add方法

boolean add(E)；//默认直接在末尾添加元素

public boolean add(E e) {    
    //确定内部容量是否够了，size是数组中数据的个数，因为要添加一个元素，所以size+1，先判断size+1的这个数数组能否放得下，就在这个方法中去判断是否数组.length是否够用了。
        ensureCapacityInternal(size + 1);  
        //在数据中正确的位置上放上元素e，并且size++
        elementData[size++] = e;
        return true;
    }

ensureCapacityInternal(xxx);

private void ensureCapacityInternal(int minCapacity) {
        if (elementData == EMPTY_ELEMENTDATA) { //判断初始化的elementData是不是空的数组，也就是没有长度。因为如果是空的话，minCapacity=size+1；其实就是等于1，空的数组没有长度就存放不了，所以就将minCapacity变成10，也就是默认大小，但是在这里，还没有真正的初始化这个elementData的大小。
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        //确认实际的容量，上面只是将minCapacity=10，这个方法就是真正的判断elementData是否够用
        ensureExplicitCapacity(minCapacity);
    }

ensureExplicitCapacity(xxx);

private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
//minCapacity如果大于了实际elementData的长度，那么就说明elementData数组的长度不够用，不够用那么就要增加elementData的length。
/*第一种情况：由于elementData初始化时是空的数组，那么第一次add的时候，minCapacity=size+1；也就minCapacity=1，在上一个方法(确定内部容量ensureCapacityInternal)就会判断出是空的数组，就会将minCapacity=10，到这一步为止，还没有改变elementData的大小，
　第二种情况：elementData不是空的数组了，那么在add的时候，minCapacity=size+1；也就是minCapacity代表着elementData中增加之后的实际数据个数，拿着它判断elementData的length是否够用，如果length不够用，那么肯定要扩大容量，不然增加的这个元素就会溢出。
*/
        if (minCapacity - elementData.length > 0)
            grow(minCapacity); //arrayList能自动扩展大小的关键方法就在这里了
    }

grow(xxx);　　//arraylist核心的方法，能扩展数组大小的关键。

private void grow(int minCapacity) {
        int oldCapacity = elementData.length;  //将扩充前的elementData大小给oldCapacity
        int newCapacity = oldCapacity + (oldCapacity >> 1);    //newCapacity就是1.5倍的oldCapacity
        if (newCapacity - minCapacity < 0)//这句话就是适应于elementData为空数组的时候，length=0，那么oldCapacity=0，newCapacity=0，所以这个判断成立，在这里就是真正的初始化elementData的大小了，就是为10。
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)//如果newCapacity超过了最大的容量限制，就调用hugeCapacity，也就是将能给的最大值给newCapacity
            newCapacity = hugeCapacity(minCapacity);
        //新的容量大小已经确定好了，就copy数组，改变容量大小。
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

hugeCapacity();

//这个就是上面用到的方法，就是用来赋最大值。
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) 
            throw new OutOfMemoryError();
//如果minCapacity都大于MAX_ARRAY_SIZE，那么就Integer.MAX_VALUE返回，反之将MAX_ARRAY_SIZE返回。因为maxCapacity是三倍的minCapacity，可能扩充的太大了，就用minCapacity来判断了。
//Integer.MAX_VALUE:2147483647   MAX_ARRAY_SIZE：2147483639  也就是说最大也就能给到第一个数值。还是超过了这个限制，就要溢出了。相当于arraylist给了两层防护。
        return (minCapacity > MAX_ARRAY_SIZE) ?Integer.MAX_VALUE : MAX_ARRAY_SIZE;
    }

void add(int ,E);　　//在特定的位置添加元素，也就是插入元素

public void add(int index, E element) {
        rangeCheckForAdd(index);//检查index也就是插入的位置是否合理。
//跟上面的分析一样，具体看上面
        ensureCapacityInternal(size + 1); 
//这个方法就是用来在插入元素之后，要将index之后的元素都往后移一位，
        System.arraycopy(elementData, index, elementData, index + 1,  size - index);  //　System.arraycopy(...)：就是将elementData在插入位置后的所有元素往后面移一位
//在目标位置上存放元素
        elementData[index] = element;
        size++;    //size增加1
    }

rangeCheckForAdd(index)

private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)   //插入的位置肯定不能大于size 和小于0
　　　　　//如果是，就报这个越界异常
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

2.删除方法

　remove(int) 方法：通过删除指定位置上的元素

public E remove(int index) {
        rangeCheck(index);//检查index的合理性
        modCount++;//这个作用很多，比如用来检测快速失败的一种标志。
        E oldValue = elementData(index);//通过索引直接找到该元素
        int numMoved = size - index - 1;//计算要移动的位数。
        if (numMoved > 0)
//这个方法也已经解释过了，就是用来移动元素的。
            System.arraycopy(elementData, index+1, elementData, index, numMoved);
//将--size上的位置赋值为null，让gc(垃圾回收机制)更快的回收它。
            elementData[--size] = null; 
//返回删除的元素。
return oldValue;
    }

　remove(Object)：这个方法可以看出来，arraylist是可以存放null值的。

//就是通过元素来删除该元素，就依次遍历，如果有这个元素，就将该元素的索引传给fastRemobe(index)，使用这个方法来删除该元素，fastRemove(index)方法的内部跟remove(index)的实现几乎一样，这里最主要是知道arrayList可以存储null值。
     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;
    }

clear()：将elementData中每个元素都赋值为null，等待垃圾回收将这个给回收掉，所以叫clear；

public void clear() {
        modCount++;
        for (int i = 0; i < size; i++)
            elementData[i] = null;
        size = 0;
    }

removeAll(collection c)

1  public boolean removeAll(Collection<?> c) {
2          return batchRemove(c, false);//批量删除
3      }

　　其中的batchRemove(xx,xx)：用于两个方法，一个removeAll()：它只清楚指定集合中的元素，retainAll() 用来测试两个集合是否有交集。

//这个方法，用于两处地方，如果complement为false，则用于removeAll；如果为true，则给retainAll()用
   private boolean batchRemove(Collection<?> c, boolean complement) {
        final Object[] elementData = this.elementData; //将原集合，记名为A
        int r = 0, w = 0;   //r用来控制循环，w是记录有多少个交集
        boolean modified = false;  
        try {
            for (; r < size; r++)
//参数中的集合C一次检测集合A中的元素是否有，
                if (c.contains(elementData[r]) == complement)
//有的话，就给集合A
                    elementData[w++] = elementData[r];
        } finally {
//如果contains方法使用过程报异常
            if (r != size) {
//将剩下的元素都赋值给集合A，
                System.arraycopy(elementData, r, elementData, w, size - r);
                w += size - r;
            }
            if (w != size) {
//这里有两个用途，在removeAll()时，w一直为0，就直接跟clear一样，全是为null。
//retainAll()：没有一个交集返回true，有交集但不全交也返回true，而两个集合相等的时候，返回false，所以不能根据返回值来确认两个集合是否有交集，而是通过原集合的大小是否发生改变来判断，如果原集合中还有元素，则代表有交集，而元集合没有元素了，说明两个集合没有交集。
          
                for (int i = w; i < size; i++)
                    elementData[i] = null;
                modCount += size - w;
                size = w;
                modified = true;
            }
        }
        return modified;
    }