ArrayList 1.8 源码分析

ArrayList 简介

ArrayList是可以动态增长和缩减的索引序列，它是基于数组实现的List类。数组元素类型为Object类型，即可以存放所有类型数据。
ArrayList和Vector的区别：ArrayList是线程不安全的，当多条线程访问同一个ArrayList集合时，程序需要手动保证该集合的同步性，而Vector则是线程安全的。
ArrayList和LinkedList的区别 : ArrayList底层是数组结构,查询快,增删慢, LinkedList底层是链表结构,增删快,查询慢

ArrayList 继承结构

继承了AbstractList 抽象类, 实现了 List, RandomAccess, Cloneable, java.io.Serializable 接口

1. AbstractList 抽象类实现了List
   接口,再实现一些通用的方法.当ArrayList类继承该类时,只需要实现自己特有的方法即可,较少了重复代码 AbstractList
   抽象类已经实现了List 接口,为什么ArrayList类还有实现List 接口, 网上写该类的作者给的答复是 :
   这其实是一个mistake，因为他写这代码的时候觉得这个会有用处，但是其实并没什么用，但因为没什么影响，就一直留到了现在。
   RandomAccess接口：这个是一个标记性接口，通过查看api文档，它的作用就是用来快速随机存取，有关效率的问题，在实现了该接口的话，那么使用普通的for循环来遍历，性能更高,
   而没有实现该接口的话，使用Iterator来迭代，这样性能更高
   Cloneable接口：实现了该接口，就可以使用Object.Clone()方法了。
   Serializable接口：实现该序列化接口，表明该类可以被序列化，什么是序列化？简单的说，就是能够从类变成字节流传输，然后还能从字节流变成原来的类。

主要成员变量

//默认初始容量
private static final int DEFAULT_CAPACITY = 10;
//默认的空数组 有参构造用
private static final Object[] EMPTY_ELEMENTDATA = {};
//默认的空数组 , 无参构造用,在add()方法中区分是否需要使用默认的初始容量
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//真正用于存放数据的数组, 缓存数组，它通常会预留一些容量, transient修饰,不被序列化
transient Object[] elementData;
//数组元素个数
private int size;
//集合被操作次数，次数对不上抛出ConcurrentModificationException()异常
protected transient int modCount = 0;

ArrayList的elementData是用transient修饰的
说明：ArrayList实现了Serializable接口，这意味着ArrayList是可以被序列化的，用transient修饰elementData意味着我不希望elementData数组被序列化
理解：序列化ArrayList的时候，ArrayList里面的elementData未必是满的，比方说elementData有10的大小，但是我只用了其中的3个，那么是否有必要序列化整个elementData呢？
显然没有这个必要，因此ArrayList中重写了writeObject方法。
优点：这样做既提高了序列化的效率，减少了无意义的序列化；而且还减少了序列化后文件大小。

构造函数

无参构造
ArrayList()
直接将 DEFAULTCAPACITY_EMPTY_ELEMENTDATA 空数组赋值给elementData缓存数组;
所以一般直接new ArrayList() 返回的初始容量其实是为 0
有参构造一
ArrayList(int initialCapacity)
如果传入的初始容量大于0就直接new 一个该初始容量的数组赋值给缓存数组,等于 0 就将EMPTY_ELEMENTDATA 空数组赋值给缓存数组,其他就抛出IllegalArgumentException异常
有参构造二
ArrayList(Collection<? extends E> c)
将传入的测试使用Collection接口的toArray()方法转成数组赋值给缓存数组,判断该数组大小是不是大于0,小于0 就返回 EMPTY_ELEMENTDATA 空数组,否则判断是不是object数组,不是就需要使用Arrays.copyOf() 方法将该数组转成object数组

常用方法

add(E e)

将指定的元素追加到此列表的末尾。

调用ensureCapacityInternal(size + 1)方法自动扩容,确保数组有足够的容量，然后元素将直接赋值到缓存数组的size+1位置,最后返回true.
ensureCapacityInternal(size + 1)方法调用了ensureExplicitCapacity(int minCapacity)方法,该方法的 minCapacity参数由calculateCapacity(Object[] elementData, int minCapacity)方法返回. 在calculateCapacity(Object[] elementData, int minCapacity)方法中先判断数组是不是等于无参构造赋值的DEFAULTCAPACITY_EMPTY_ELEMENTDATA空数组,是的话返回DEFAULT_CAPACITY(10)和minCapacity参数二者的最大值,不是该数组的话直接返回minCapacity参数.

	private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);//返回二者的最大值
        }
        return minCapacity;
    }

ensureExplicitCapacity(int minCapacity)方法中如果minCapacit 大于 缓存数组长度的大小的话就调用grow(xxx); arrayList核心的方法，能扩展数组大小的真正秘密。

	private void grow(int minCapacity) {
        int oldCapacity = elementData.length;
 		//oldCapacity >> 1等价于 oldCapacity / 2^1，右移n 除以2的n次方,左移n 乘以2的n次方
 		//也就是说ArrayList默认的扩容大小是当前数组大小的一半。
        int newCapacity = oldCapacity + (oldCapacity >> 1);
 		//如果新的容量比指定的容量小,则把新的容量改为指定容量
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
 		//如果新的容量比最大的数组大小还大,则进行大容量扩容为 Integer.MAX_VALUE 大小
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
 		//创建新容量长度的数组，并把原来的元素赋值到新数组中，实现扩容 + 复制 元素的效果
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

在此可以发现我们直接new ArrayList() 返回的是一个0大小的集合,只有在第一次调用add()方法的时候才会初始化为默认10大小的集合.后续正常情况下扩容大小为当前大小的1.5倍, 特殊情况下（新扩展数组大小已经达到了最大值）则只取最大值(Integer最大值)。

add(int index, E element)

在此列表中的指定位置插入指定的元素。

首先确认是否会索引越界,然后调用ensureCapacityInternal(size + 1)方法确保数组有足够的容量，System.arraycopy()将index后面的元素往后移一个位置, 将缓存数组的index位赋值为添加的元素,最后size ++

addAll(Collection<? extends E> c)

将c集合中的所有元素添加到该集合中

先将集合转成数组,然后调用ensureCapacityInternal()方法自动扩容, 确保数组有足够的容量
然后 System.arraycopy()方法赋值数组,最后size大小加上数组大小

addAll(int index, Collection<? extends E> c)

将c集合中的所有元素添加到该集合指定位置中

与上面addAll()方法类似,只是加了一层如果当前size 大于index就使用System.arraycopy()将缓存数组元素位移

get(int index)

返回此列表中指定位置的元素。

确认不会索引越界后直接返回缓存数组的index位置元素

set(int index, E element)

用指定的元素替换此列表中指定位置的元素。

确认是否索引越界,先获取index位置的旧元素,然后将新元素赋值到缓存数组的该位置,最后返回旧元素

remove(int index)

删除指定位置元素

System.arraycopy()将缓存数组index后面的元素向前移动一位,然后将最后的元素设为null,返回删除的元素

remove(Object o)

从列表中删除指定元素的第一个出现（如果存在）。

判断元素是否为null,然后循环数组获取该元素的索引位置,最后与remove(int index)方法一样位移缓存数组

removeRange(int fromIndex, int toIndex)

从这个列表中删除所有索引在 fromIndex （含）和 toIndex之间的元素。

位移元素,将最后删除长度位置的元素设为null,修改size大小

clear()

从列表中删除所有元素。

for循环将缓存数组的每个元素设为null,并将size大小设为0

removeAll(Collection<?> c)

从此列表中删除指定集合中包含的所有元素。

retainAll(Collection<?> c)

仅保留此列表中包含在指定集合中的元素。

都调用batchRemove(c, boolean complement);方法, removeAll 传的false, retainAll传true

	private boolean batchRemove(Collection<?> c, boolean complement) {
        //final 修饰的数组，指定数组指向内存空间固定，数组内部数值还可以更改
        final Object[] elementData = this.elementData;
        int r = 0, w = 0;		//r 控制循环, w 记录有多少交集
        boolean modified = false;
        try {
            for (; r < size; r++)
 		//参数集合是否包含且返回值与传入的参数complement相同
                if (c.contains(elementData[r]) == complement)	
                    elementData[w++] = elementData[r];	//将需要的元素从开始逐个修改
        } finally {
     //r != size 表示for循环抛异常了
            if (r != size) {
 //将剩下的元素位移
                System.arraycopy(elementData, r,
                                 elementData, w,
                                 size - r);
                w += size - r;
            }
     //w 等于size说明二个集合的元素相同.所以直接返回false
            if (w != size) {
                for (int i = w; i < size; i++)
                    elementData[i] = null;	//将后面的元素都设为null, 让gc(垃圾回收机制)更快的回收。
                modCount += size - w;
                size = w;	//修改size大小
                modified = true;
            }
        }
        return modified;
    }

indexOf(Object o)

返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。

判断是否为null,然后for循环,null用 == 判断,其他用equals判断,相等就返回该索引,否则就返回 -1

lastIndexOf(Object o)

返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。

与indexOf方法类似,只不过倒过来for循环

clone()

返回此 ArrayList实例的浅拷贝。

由于ArrayList底层是数组,数组存的都是地址值,所以该方法返回的也是之前的地址值.
深拷贝一般是重写object的 clone方法,重写new 一个对象,将当前属性赋值给该对象

浅拷贝和深拷贝的区别 :

• 浅拷贝修改该集合源集合数据也会相应改变,因为返回的还是源数据的地址值
• 深拷贝修改该集合源集合数据不会改变,因为返回的是一个新的地址值.

subList(int fromIndex, int toIndex)

返回此列表中指定的 fromIndex（包括）和 toIndex之间的独占视图。

该方法是new 一个subList内部类,改变该方法返回的集合数据时,源数据也会改变,并且返回的List不能强转成其他集合类

内部类

SubList

该类继承了AbstractList类,并重写了该类的方法set, get, add, remove等方法,构造方法中把原来的List以及该List中的部分属性直接赋值给自己的一些属性了。SubList并没有重新创建一个List，而是直接引用了原有的List（返回了父类的视图），只是指定了一下他要使用的元素的范围而已（从fromIndex（包含），到toIndex（不包含））。

Itr

实现了 Iterator接口,重写了该接口中的hasNext(),next(), remove(), forEachRemaining(Consumer<? super E> consumer)方法

ListItr

继承了Itr类,并实现了 ListIterator接口