ArrayList
 
一、ArrayList简介
 
1.1ArrayList概述
 
ArrayList是可以动态增长和缩减的索引序列，它是基于数组实现的List类
 
封装了一个动态再分配的Object[] 数组
 
/**
* Default initial capacity.
*一个类对象都有一个capacity属性，表示它们所封装的Object[]数组的长度，当向ArrayList中添加元素时，该属性值会自动增加。
*/
private static final int DEFAULT_CAPACITY = 10;
 
如果想ArrayList中添加大量元素，可使用ensureCapacity方法一次性增加capcacity，可以减少增加重分配的次数提高性能 。
 
/**
     * Default initial capacity.
     *
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * Shared empty array instance used for empty instances.
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

    /**
     * Shared empty array instance used for default sized empty instances. We
     * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
     * first element is added.
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};


/**
     * Increases the capacity of this <tt>ArrayList</tt> instance, if
     * necessary, to ensure that it can hold at least the number of elements
     * specified by the minimum capacity argument.
     *
     * @param   minCapacity   the desired minimum capacity
     */
    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;//这里的值为10

        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);
        }
    }
 
ArrayList的用法和Vector的区别是：ArrayList是线程不安全的，当多条线程访问同一个ArrayList集合时，程序需要手动保证该集合的同步性，而Vector则是线程安全的。
 
ArrayList和Collection的关系
 
 
1.2 ArrayList的数据结构
 
分析一个类的时候，数据结构往往是它的灵魂所在，理解底层的数据结构其实就理解了该类的实现思路。
 
具体的实现细节再具体分析。
 
ArrayList的数据结构是：
 
 
底层的数据结构就是数组，数组元素类型为Object类型，即可以存放所有类型数据。
 
我们对ArrayList类的实例的所有的操作底层都是基于数组的。
 
二、ArrayList源码分析
 
2.1继承结构和层次关系
 
这里先说一下怎么使用idea查看类的继承结构图：Navigate -> Type Hierarchy
 

 
 
 
 
可以看到:
 
 
ArrayList extends AbstractList
 
 
AbstractList extends AbstractCollection
 
 
所有类都继承Object 所以ArrayList的继承结构就是上图所示。
 
分析：
 
1）为什么要先继承AbstractList，而让AbstractList先实现List? 而不是让ArrayList直接实现List?
 
这里是有一个思想，**接口中全部是抽象的方法，而抽象类中可以有抽象方法，还可以有具体的实现方法，**正是利用了这一点，让AbstractList是实现接口中一些通用的方法，而具体的类，如ArrayList就继承这个AbstractList类，拿到一些通用的方法，然后自己在实现一些自己特有的方法，这样一来，让代码更简洁，就继承结构最底层的类中通用的方法都抽取出来，先一起实现了，减少重复代码。
 
所以一般看到一个类上面还有一个抽象类，应该就是这个作用。
 
2）ArrayList实现了哪些接口？
 
 
List接口：我们会出现这样一个疑问，在查看了ArrayList的父类AbstractList也实现了List接口，那为什么子类ArrayList还是去实现一遍呢？
 
这其实是一个mistake,因为他写这代码的时候觉得这个会有用处，但是其实并没什么用，但因为没什么影响，就一直留到了现在。
 
 
RandomAccess接口：这个是一个标记性接口，通过查看api文档，它的作用就是**用来快速随机存取，有关效率的问题，在实现了该接口的话，那么使用普通的for循环来遍历，性能更高，**例如arrayList。而没有实现该接口的话，使用Iterator来迭代，这样性能更高，例如linkedList。所以这个标记性只是为了让我们知道用什么样的方式去获取数据性能更好。
 
 
Cloneable接口：实现了该接口，就可以使用Object.Clone()方法了。
 
 
Serializable接口：实现该**序列化接口，表明该类可以被序列化。**什么是序列化？简单的说，就是能够从类变成字节流传输，然后还能从字节流变成原来的类。
 
 
2.2 类中的属性
 
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; // non-private to simplify nested class access

    // 实际元素大小， 默认为0
    private int size;
    
    // 最大数组容量
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
}
 
2.3 构造方法
 
ArrayList有三个构造方法：
 
 
1）无参构造方法
 
/**
     * Constructs an empty list with an initial capacity of ten.这里就说明了默认会给10的大小，所以说一开始arrayList的容量是10
     */
	//ArrayList中存储数据的其实就是一个数组，这个数组就是elementData,也就是之前的 private transient Object[] elementData;
    public ArrayList() {
        //调用父类中的无参构造方法，父类中的是个空的构造方法
        super();
        //DEFAULTCAPACITY_EMPTY_ELEMENTDATA 是个空的Object[],将elementData初始化，elementData也是个Object[]类型，空的Object[]会给默认大小10，之后解释什么时候赋值
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
 
2）有参构造函数
 
    /**
     * Constructs an empty list with the specified initial capacity.
     *
     * @param  initialCapacity  the initial capacity of the list
     * @throws IllegalArgumentException if the specified initial capacity
     *         is negative
     */
    public ArrayList(int initialCapacity) {
        // 父类中空的构造方法
        super();
        //判断自定义大小的容量情况，>0正常创建，=0直接赋值EMPT_ELEMENTDATA，<0抛出异常
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }
 
3）有参构造方法（不常用）
 
	//这个构造方法不常用，举个例子就能明白什么意思
	/*
		Student extends Person
		ArrayList<Person>、Person这里就是泛型
		还有一个Collection<Student>、由于这个Student继承了Person，那么根据下面这个构造方法，就可以把这个Collection<Student>转换为ArrayList<Student>
		这就是这个构造方法的作用
	*/
    public ArrayList(Collection<? extends E> c) {
        //转换为数组，并且赋值给elementData元素数组
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            //每个集合的toarray()的实现方法不一样，所以需要判断一下，如果不是Object[].class类型
            //如果不是Object[].class类型，那么就需要使用ArrayList中的方法去改造一下
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // 如果没有一个元素，将空的数组EMPTY_ELEMENTDATA赋值给elementData
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

 
总结：arrayList的构造方法就做一件事情，就是初始化一下储存数据的容器，其实本质上就是一个数组，在其中就叫elementData。
 
2.4 核心方法
 
2.4.1 add()方法（4个）
 
 
1）boolean add(E); //默认直接在末尾添加元素
 
   /**
     * Appends the specified element to the end of this list.
     *
     * @param e element to be appended to this list
     * @return <tt>true</tt> (as specified by {@link Collection#add})
     */
    public boolean add(E e) {
        //确定内部容量是否够了，size是数组中数据的个数，因为要添加一个元素，所以size+1
        //先判断size+1的这个数 数组能否放得下，就在这个方法中去判断是否数组.length够用了
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //在数据中正确的位置上放上元素e,并且size++
        elementData[size++] = e;
        return true;
    }
 
分析：
 
ensureCapacityInternal(xxx)；确定内部容量的方法
 
private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
 
private static int calculateCapacity(Object[] elementData, int minCapacity) { 
    //判断初始化的elementData是不是空的数组，也即没有长度
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {  
        //如果是空的话，minCapacity=size+1;其实就是等于1，空的数组没有长度就存放不了，所以就将minCapacity变成10，也就是默认大小，但是到这来们还没有真正的初始化这个elementData的大小
        return Math.max(DEFAULT_CAPACITY, minCapacity);    
    }    
    return minCapacity;    
}
 
/**
*确认实际的容量，上面只是将minCapacity=10，这个方法就是真正的判断elementData是否够用
*/
private void ensureExplicitCapacity(int minCapacity) {    
    modCount++;    
    
    // overflow-conscious code    
    //minCapacity如果大于了实际elementData的长度，那么就说明elementData数组的长度不够用，不够用那么就要增加elementData的length。
    if (minCapacity - elementData.length > 0)        
        //arrayList能自动扩展大小的关键方法就在这里了
        grow(minCapacity);
}
 
grow(xxx)；arrayList核心的方法，能扩展数组大小的真正秘密
 

    private void grow(int minCapacity) {
        // overflow-conscious code
        //将扩充前的elementData大小给oldCapacity
        int oldCapacity = elementData.length;
        //newCapacity就是1.5倍的oldCapacity，因为向右移1位代表除以2
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            //这句话就是适应elementData空数组的时候，length=0,那么oldCapacity=0,newCapacity=0,所以这个判断成立，在这里就是真正的初始化elementData的大小了，前面的工作都是准备工作。
            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返回。因为maxCapacity是三倍的minCapacity,可能扩充的太大了，就用minCapacit来判断了。
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }
 
2.4.2 删除方法
 
其实这几个删除方法都是类似的。我们选择几个讲，其中fastRemove(int)方法是private的,是提供给remove(Object)这个方法用。
 

 
 
 1）remove(int n): 通过删除指定位置上的元素
 
  public E remove(int index) {
        // 检查index的合理性
        rangeCheck(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值的
 
//通过元素来删除该元素，就依次遍历，如果有这个元素，就将该元素的索引传给fastRemove(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++;

        // clear to let GC do its work
        for (int i = 0; i < size; i++)
            elementData[i] = null;

        size = 0;
    }
 
4)removeAll(Collection<?> c)
 

    public boolean removeAll(Collection<?> c) {
        //如果C为空，抛出空指针异常
        Objects.requireNonNull(c);
        // 批量删除
        return batchRemove(c, false);
    }
 
5)batchRemove(Collection<?> c, boolean complement):用于两个方法
 
removeAll():它只清楚指定集合中的元素,当complement为false
retainAll():用来测试两个集合是否有交集,当complement为true
 
/**
*这个方法用于两处地方：
*如果complement为false:用于removeAll()
*如果complement为true :用于retainAll():这个方法是用来检测两个集合是否有交集的。
*/
private boolean batchRemove(Collection<?> c, boolean complement) {
    	// 将原集合，记名为A
        final Object[] elementData = this.elementData;
    	// r用来控制循环，w是记录有多少个交集
        int r = 0, w = 0;
        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;
    }
 
总结：remove函数用户移除指定下标的元素，此时会指定下标到数组末尾的元素向前移动一个单位。，并且会把数组最后一个元素设置为null,这样是为了方便之后将整个数组不被使用时，会被GC，可以作为小的技巧使用。
 
2.4.3 set()方法
 
	public E set(int index, E element) {
        // 检验索引是否合法
        rangeCheck(index);
		// 旧值
        E oldValue = elementData(index);
        // 赋新值
        elementData[index] = element;
        // 返回旧值
        return oldValue;
    }
 
说明：设定指定下标索引的元素值
 
2.4.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;
    }
 
说明：从头开始查找与指定元素相等的元素，注意，是可以查找null元素的，意味着ArrayList中可以存放null元素的。与此函数对应的lastIndexOf,表示从尾部开始查找。
 
2.4.5 get()方法
 

    public E get(int index) {
        // 检验索引是否合法
        rangeCheck(index);

        return elementData(index);
    }
 
说明：get函数会检查索引值是否合法（只检查是否大于size,而没有检查是否小于0），值得注意的是，在get函数中存在element函数，element函数用于返回具体的元素，具体函数如下：
 
	E elementData(int index) {
        return (E) elementData[index];
    }
 
说明：返回的值经过了向下转型（Object -> E）,这些是对我们应用程序屏蔽的小细节。
 
三、总结
 
arrayList可以存放null
arrayList本质上就是一个elementData数组
arrayList区别于数组的地方在于能够自动扩展大小，其中关键的方法就是gorw()方法
arrayList中removeAll(Collection c)和clear()的区别就是removeAll可以删除批量指定的元素，而clear是全是删除集合中的元素
arrayList由于本质是数组，所以它在数据的查询方面会很快，而在插入删除这些方面，性能下降很多，有移动很多数据才能达到应有的效果
arrayList实现了RandomAccess，所以在遍历它的时候推荐使用for循环
 
注明，参考 https://www.cnblogs.com/zhangyinhua/p/7687377.html