【java集合总结】-- ArrayList源码解析

1、前言

　　要想深刻的了解集合就必需要经过分析源码来了解它，那如何来看源码，要看什么东西呢？主要从三个方面：

　　一、看继承结构

　　　　看这个类的继承结构，处于一个什么位置，不须要背记，有个大概的感受就能够，我本身感受了解了以后内心都舒服些。

　　二、看构造方法

　　　　很重要，通常在构造方法中会作不少事情，要跟踪方法中的方法。

　　三、看经常使用方法

　　　　不必全部方法都去了解，知道经常使用、核心的方法实现便可。

　　本文参考：http://www.javashuo.com/article/p-dxhxlxrw-co.html

2、ArrayList概述

　　1）ArrayList是能够动态增加和缩减的索引序列，它是基于数组实现的List类。

　　2）该类封装了一个动态再分配的Object[]数组，每个类对象都有一个capacity属性，表示它们所封装的Object[]数组的长度，当向ArrayList中添加元素时，该属性值会自动增长。

　　3）若是想ArrayList中添加大量元素，可以使用ensureCapacity方法一次性增长capacity，能够减小增长重分配的次数提升性能。

　　4）ArrayList的用法和Vector向相似，可是Vector是一个较老的集合，具备不少缺点，不建议使用。

　　　　另外，ArrayList和Vector的区别是：ArrayList是线程不安全的，当多条线程访问同一个ArrayList集合时，程序须要手动保证该集合的同步性，而Vector则是线程安全的。

　　5）继承关系图：

　　

3、源码分析

3.一、继承结构和层次关系

 

分析：

　　为何要让AbstractList先实现List<E>，而后在让ArrayList继承AbstractList？为何不让ArrayList直接实现List<E>？

　　这里是一种默认的写法，也能够说是一种思想：让AbstractList去实现接口中一些通用的方法，而具体的类ArrayList就继承这个AbstractList类，拿到一些通用的方法，而后本身在实现一些本身特有的方法。

　　这样一来代码更简洁，而且若是有多个类继承ArrayList，就能够直接继承ArrayList中通用的方法，减小重复代码。因此通常看到一个类上面还有一个抽象类，应该就是这个做用。

3.二、类中属性

　　没什么可说的，看注释便可。

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable { // 版本号 private static final long serialVersionUID = 8683452581122892189L; // 缺省容量 private static final int DEFAULT_CAPACITY = 10; // 空对象数组 private static final Object[] EMPTY_ELEMENTDATA = {}; // 缺省空对象数组 private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; // 元素数组 transient Object[] elementData; // 实际元素大小，默认为0 private int size; // 最大数组容量 private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8; }

3.三、构造方法

 ArrayList有三个构造方法：

 　　一、无参构造函数

　　

　　DEFAULTCAPACITY_EMPTY_ELEMENTDATA是一个空的Object[]，将elementData初始化，elementData也是个Object[]类型。空的Object[]会给默认大小10，等会解释何时赋值的。

　　ArrayList中储存数据的其实就是一个数组，这个数组就是elementData，下图中有

　　

　　二、有参构造函数一

　　逻辑很简单，不解释了。

　　

　　三、有参构成函数二（不经常使用）

　　

　　总结：arrayList的构造方法就作一件事情，就是初始化一下储存数据的容器，其实本质上就是一个数组，在其中就叫elementData。

3.四、核心方法

 3.4.一、添加方法

　　添加方法共有四个，这里只介绍经常使用的两种。

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

　　

　　分析：

　　ensureCapacityInternal方法为肯定容量方法。　　 
 在添加元素以前须要肯定数组是否能放的下，size是数组中数据的个数，由于要添加一个元素，因此size+1。　　

　　

　　ensureCapacityInternal方法中分两步：

　　a、首先肯定最小容量：判断elementData ==DEFAULTCAPACITY_EMPTY_ELEMENTDATA，即判断初始化的elementData是否是空的数组。而后找出默认容量和参数容量中大的。

 　　

　　b、调用ensureExplicitCapacity方法，该方法才是真的判断容量是否够用的方法，若是不过用则扩容

　　

　　在ensureExplicitCapacity方法中，若是须要的容量大于elementData的容量，则调用grow方法进行扩容，grow方法是真正的扩容方法。

　　至于modCount++这个做用不少，好比用来检测快速失败的一种标志，这个对于咱们目前研究的问题无影响，不用在乎。

　　private void grow(int minCapacity) { // overflow-conscious code
        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); // minCapacity is usually close to size, so this is a win: //新的容量大小已经肯定好了，就copy数组，改变容量大小咯。
        elementData = Arrays.copyOf(elementData, newCapacity); }

　　hugeCapacity();  

　　//这个就是上面用到的方法，很简单，就是用来赋最大值。
    private static int hugeCapacity(int minCapacity) { if (minCapacity < 0) // overflow
            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; }

　　 2）void add(int，E)；在特定位置添加元素，也就是插入元素

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

　　分析：

　　rangeCheckForAdd方法

　　

　　注意：

　　　　当调用空的构成函数建立ArrayList时，初始化List大小是在第一次添加时进行。

 3.4.二、删除方法

　　

　　和添加方法同样，这几个删除方法都是相似的，抽两个分析下就行，其余的都差很少。

　　另外，fastRemove(int)方法是private的，是提供给remove(Object)这个方法用的。

 　　1）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; // clear to let GC do its work //返回删除的元素。
        return oldValue; }

 　　2）remove(Object)：这个方法能够看出来，arrayList是能够存放null值得。

　　

　　3）clear()：将elementData中每一个元素都赋值为null，等待垃圾回收将这个给回收掉，因此叫clear

 　　

　　4）removeAll(collection c)批量删除

　　

　　分析：

　　batchRemove(xx,xx)：

//这个方法，用于两处地方，若是complement为false，则用于removeAll若是为true，则给retainAll()用，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 { // Preserve behavioral compatibility with AbstractCollection, // even if c.contains() throws. 　　//若是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，因此不能根据返回值来确认两个集合是否有交集，而是经过原集合的大小是否发生改变来判断，若是原集合中还有元素，则表明有交集，而元集合没有元素了，说明两个集合没有交集。 // clear to let GC do its work
                for (int i = w; i < size; i++) elementData[i] = null; modCount += size - w; size = w; modified = true; } } return modified; }

 3.4.三、indexOf方法

// 从首开始查找数组里面是否存在指定元素
    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; }

3.4.四、get方法　

　　

　　要先检测因此是否合法。

　　注意：在get函数中存在element函数，element函数用于返回具体的元素，具体函数以下：

　　

　　说明：返回的值都通过了向下转型（Object -> E），这些是对咱们应用程序屏蔽的小细节。

4、总结

　　1）arrayList能够存放null。
　　2）arrayList本质上就是一个elementData数组。
　　3）arrayList区别于数组的地方在于可以自动扩展大小，其中关键的方法就是gorw()方法。
　　4）arrayList中removeAll(collection c)和clear()的区别就是removeAll能够删除批量指定的元素，而clear是删除集合中的所有元素。
　　5）arrayList因为本质是数组，因此它在数据的查询方面会很快，而在插入删除这些方面，性能降低不少，由于须要移动不少数据才能达到应有的效果　　6）arrayList实现了RandomAccess，因此在遍历它的时候推荐使用for循环。