ArrayList源码分析和缩减版手写ArrayList（jdk1.8和1.9）

参考：https://blog.csdn.net/weixin_38405253/article/details/100170568
https://www.cnblogs.com/gxl1995/p/7534171344218b3784f1beb90d621337.html
https://www.cnblogs.com/yonyong/p/9323546.html
https://www.cnblogs.com/mabingxue/p/9176324.html

看源码一定要有耐心，第一次看可能看不懂，后面再看可能还是看不懂，但是别放弃治疗，我还是要看。不过这ArrayList我还是看的懂一些的。我看了很久发现我的idea里面了源码和我查到的很多分析的源码都不一样，找了很久发现，原来大家都是jdk1.8版本的，我的是jdk1.9版本的，里面有一些不一样，发现大家都推荐jkd1.8，普遍推荐吧，应该。
https://segmentfault.com/a/1190000019326016?utm_source=tag-newest（这个好像是jdk1.9的ArrayList分析）

看了上面参考里的源码分析和自己看源码，就记录一下自己的所得，大多都是复制的，不过也加了自己的一些见解（文章中可能会有错误），所以写个随笔加深印象。

简介：

ArrayList也就是动态数组，底层是数组实现的。先说说数组，数组在内存中是连续存储的，它的索引速度非常快，赋值和修改元素很快捷。因为数组是连续存储的，所以Arraylist在内存中也是连续的。索引Arraylist的时候是要比原生数组慢的，因为你要用get方法，也就是函数调用，而数组就是直接[]访问，相当于直接操作内存地址，速度肯定比函数调用快。但是数组有不足，在数组的两个数据中间插入数据是很麻烦的，并且在声明数组的时候我们必须同时指定数组的长度，数组的长度过长，会造成内存浪费，数组的长度过短会造成数据的溢出错误。所以就有了Arraylist来有取舍的优化，ArrayList和Array各有优点和用处。

Array和ArrayList的一些不同点：

1、Array可以包含基本类型和对象类型，ArrayList只能包含对象类型。

2、Array大小是固定的，ArrayList的大小是动态变化的。

3、ArrayList提供了更多的方法和特性，比如：add()，removeAll()，iterator()等等。所以ArrayList的可操作性就更强了，可以对数据方便的添加、插入和删除。（其实它的插入、删除的效率不高，LinkedList的插入、删除高）

ArrayList还存在不安全类型和装箱和拆箱的缺点，可以用泛型解决这些缺点。ArrayList还是线程不安全的，因为它里面的方法不能保证操作的原子性。

ArrayList继承了AbstractList，实现了List、RandomAccess[随机访问], Cloneable[可克隆], java.io.Serializable[序列化]。

扩展：序列化是指：将对象转换成以字节序列的形式来表示，以便用于持久化和传输。

源码分析（不是很全）（jdk1.8）

1、属性分析

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    private static final long serialVersionUID = 8683452581122892189L;

    /**
     * Default initial capacity.默认初始化容量
     */

    private static final int DEFAULT_CAPACITY = 10;

    /**如果用户自定义容量为0，默认用下面这个来初始化ArrayList，空数组
     * 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.
     */这又来了一个空数组，当用户没有指定ArrayList的容量时（即调用无参构造函数），返回的是该
　　　　数组，当用户第一次添加元素是，该数组会扩容，变为默认容量为10的一个数组，在ensureCapacity（）实现
　　　　它与上一个的区别就是该数组是默认返回的，而上一个是在用户指定容量为0时返回
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    /**
     * The array buffer into which the elements of the ArrayList are stored.
     * The capacity of the ArrayList is the length of this array buffer. Any
     * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
     * will be expanded to DEFAULT_CAPACITY when the first element is added.
     */这是我们ArrayList底层用到的数组，用transient修饰
    transient Object[] elementData; // non-private to simplify nested class access

    /**
     * The size of the ArrayList (the number of elements it contains).
     *
     * @serial
     */ArrayList实际存储的数据数量
    private int size;

transient关键字解析：

Java中transient关键字的作用，简单地说，就是让某些被修饰的成员属性变量不被序列化。

有了transient关键字声明，则这个变量不会参与序列化操作，即使所在类实现了Serializable接口，反序列后该变量为空值。

那么问题来了：ArrayList中数组声明：transient Object[] elementData;，事实上我们使用ArrayList在网传输用的很正常，并没有出现空值。

原来：ArrayList在序列化的时候会调用writeObject()方法，将size和element写入ObjectOutputStream；反序列化时调用readObject()，从ObjectInputStream获取size和element，再恢复到elementData。

那为什么不直接用elementData来序列化，而采用上诉的方式来实现序列化呢？

原因在于elementData是一个缓存数组，它通常会预留一些容量，等容量不足时再扩充容量，那么有些空间可能就没有实际存储元素，采用上诉的方式来实现序列化时，就可以保证只序列化实际存储的那些元素，而不是整个数组，从而节省空间和时间。

2、构造方法分析

    /**
     * 创建一个初试容量的、空的ArrayList
     * @param  initialCapacity初始容量
     * @throws IllegalArgumentException当初始容量值非法(小于0)时抛出
     */
    public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                    initialCapacity);
        }
    }

    /**
     * 无参构造函数：
     * - 创建一个空的 ArrayList，此时其内数组缓冲区elementData = {}, 长度为 0
     * - 当元素第一次被加入时，扩容至默认容量 10
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    /**
     * 创建一个包含collection的ArrayList
     * @param c 要放入 ArrayList 中的集合，其内元素将会全部添加到新建的 ArrayList 实例中
     * @throws NullPointerException 当参数 c 为 null 时抛出异常
     */
    public ArrayList(Collection<? extends E> c) {
        //将集合转化成Object[]数组
        elementData = c.toArray();
        //把转化后的Object[]数组长度赋值给当前ArrayList的size，并判断是否为0
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            // 这句话意思是：c.toArray 可能不会返回 Object[]，可以查看 java 官方编号为 6260652 的 bug
            if (elementData.getClass() != Object[].class)
                // 若 c.toArray() 返回的数组类型不是 Object[]，则利用 Arrays.copyOf(); 来构造一个大小为 size 的 Object[] 数组
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // 替换空数组
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

3、主干方法

trimToSize（）方法，这个方法用来最小化实例存储

public void trimToSize() {
        // modCount 是 AbstractList 的属性值：protected transient int modCount = 0;
        modCount++;
        if (size < elementData.length) {
            elementData = (size == 0)
              ? EMPTY_ELEMENTDATA
              : Arrays.copyOf(elementData, size);
        }
    }    

这个方法里面突然混进了一个modCount，这个数了作用是为了记录修改次数，而且这个数在本数据结构对应迭代器iterator中很重要，（Fail-Fast机制（快速失败机制））ArrayList是线程不安全的，在使用迭代器遍历List时有其他线程修改了List，会抛出java.util.ConcurrentModificationException异常。Itr类里有一个成员变量expectedModCount，它的值为创建Itr对象的时候List的modCount值。用此变量来检验在迭代过程中List对象是否被修改了，如果被修改了则抛出java.util.ConcurrentModificationException异常。更具体的可以看下面这个链接里面的
https://blog.csdn.net/ljw619/article/details/79150635（ArrayList中的modCount的作用）

下面是ArrayList的扩容机制

  public void ensureCapacity(int minCapacity) {
        // 最小扩充容量，默认是 10
        //判断是不是空的ArrayList,如果是的最小扩充容量10，否则最小扩充量为0
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
                ? 0
                : DEFAULT_CAPACITY;
        // 若用户指定的最小容量 > 最小扩充容量，则以用户指定的为准，否则还是 10
        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);
        }
    }

这上面一个ensureCapacity方法中minExpand这个参数我一开始没看懂，这个方法是提供给用户用的，感觉没啥用，在我的jkd1.9里面是把这个方法和下面一个方法合并了，在ArrayList的实现中并没有使用。我大概理解就是当我们的elementData为空的时候minExpand=10，我们指定的minCapacity如果大于minExpand（10），就会执行ensureExplicitCapacity（minCapacity）方法，如果elementData不为空则minExpand=0，我们指定的minCapacity大于minExpand（0），执行ensureExplicitCapacity（minCapacity）方法。如果有必要，增加ArrayList实例的容量，以确保它至少能容纳的数量。如果我们要看容量的话要用反射来看，size（）方法得到的是列表中的元素的个数而不是容量。

 private void ensureCapacityInternal(int minCapacity) {
        // 若 elementData == {}，则取 minCapacity 为 默认容量和参数 minCapacity 之间的最大值
        // 注：ensureCapacity() 是提供给用户使用的方法，在 ArrayList 的实现中并没有使用
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity= Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        ensureExplicitCapacity(minCapacity);
    }

上面这个ensureCapacityInternal方法是我们ArrayList实现中的方法，得到做小的扩容量

    /**
     * 私有方法：明确 ArrayList 的容量
     * - 用于内部优化，保证空间资源不被浪费：尤其在 add() 方法添加时起效
     * @param minCapacity    指定的最小容量
     */
    private void ensureExplicitCapacity(int minCapacity) {
        // 将“修改统计数”+1，该变量主要是用来实现fail-fast机制的
        modCount++;
        // 防止溢出代码：确保指定的最小容量 > 数组缓冲区当前的长度
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

ensureExplicitCapacity（）判断是否需要扩容

在我的jdk1.9中是直接把上面这三个方法直接整合了，扩容直接就用grow（）和newCapacity（），在add方法里直接grow了可以在此看一看 https://segmentfault.com/a/1190000019326016?utm_source=tag-newest（jdk1.9的ArrayList分析）

MAX_ARRAY_SIZE常量

    /**
     * 数组缓冲区最大存储容量
     * - 一些 VM 会在一个数组中存储某些数据--->为什么要减去 8 的原因
     * - 尝试分配这个最大存储容量，可能会导致 OutOfMemoryError(当该值 > VM 的限制时)
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

grow（）扩容方法

    /**
     * 私有方法：扩容，以确保 ArrayList 至少能存储 minCapacity 个元素
     * - 扩容计算：newCapacity = oldCapacity + (oldCapacity >> 1);  扩充当前容量的1.5倍
     * @param minCapacity    指定的最小容量
     */
    private void grow(int minCapacity) {
        // 防止溢出代码
        int oldCapacity = elementData.length;
        // 运算符 >> 是带符号右移. 如 oldCapacity = 10,则 newCapacity = 10 + (10 >> 1) = 10 + 5 = 15
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)  // 若 newCapacity 依旧小于 minCapacity
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)   // 若 newCapacity 大于最大存储容量，则进行大容量分配
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

hugeCapacity（）方法

    /**
     * 私有方法：大容量分配，最大分配 Integer.MAX_VALUE
     * @param minCapacity
     */
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
                Integer.MAX_VALUE :
                MAX_ARRAY_SIZE;
    }

size（）、isEmpty（）、contains（）、indexOf（）、lastIndexOf（）

    /**
     * 返回ArrayList实际存储的元素数量
     */
    public int size() {
        return size;
    }

    /**
     * ArrayList是否有元素
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 是否包含o元素
     */
    public boolean contains(Object o) {
        // 根据 indexOf() 的值(索引值)来判断，大于等于 0 就包含
        // 注意：等于 0 的情况不能漏，因为索引号是从 0 开始计数的
        return indexOf(o) >= 0;
    }

    /**
     * 顺序查找，返回元素的最低索引值(最首先出现的索引位置)
     * @return 存在？最低索引值：-1
     */
    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;
    }

    /**
     * 逆序查找，返回元素的最低索引值(最首先出现的索引位置)
     * @return 存在？最低索引值：-1
     */
    public int lastIndexOf(Object o) {
        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;
    }

toArray()

    /**
     * 返回 ArrayList 的 Object 数组
     * - 包含 ArrayList 的所有储存元素
     * - 对返回的该数组进行操作，不会影响该 ArrayList（相当于分配了一个新的数组）==>该操作是安全的
     * - 元素存储顺序与 ArrayList 中的一致
     */
    public Object[] toArray() {
        return Arrays.copyOf(elementData, size);
    }

rangeCheck（）

    /**
     * 检查数组是否在界线内
     */
    private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

add()

    public boolean add(E e) {
        // 确定ArrayList的容量大小---严谨
        // 注意：size + 1，保证资源空间不被浪费，
        // ☆☆☆按当前情况，保证要存多少个元素，就只分配多少空间资源
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

    /**
     *
     *在这个ArrayList中的指定位置插入指定的元素，
     *  - 在指定位置插入新元素，原先在 index 位置的值往后移动一位
     * @param index 指定位置
     * @param element 指定元素
     * @throws IndexOutOfBoundsException
     */
    public void add(int index, E element) {
        rangeCheckForAdd(index);//判断角标是否越界
        //看上面的，size+1，保证资源空间不浪费，按当前情况，保证要存多少元素，就只分配多少空间资源
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //第一个是要复制的数组，第二个是从要复制的数组的第几个开始，
        // 第三个是复制到那，四个是复制到的数组第几个开始，最后一个是复制长度
        System.arraycopy(elementData, index, elementData, index + 1,
                size - index);
        elementData[index] = element;
        size++;
    }

还有很多方法就不列举了，可以去上面的参考链接里面有。

在add（）方法中的size+1问题

size+1代表的含义是：

1、如果集合添加元素成功后，集合中的实际元素个数。

2、为了确保扩容不会出现错误。

假如不加一处理，如果默认size是0，则0+0>>1还是0。
如果size是1，则1+1>>1还是1。有人问:不是默认容量大小是10吗?事实上，jdk1.8版本以后，ArrayList的扩容放在add()方法中。之前放在构造方法中。我用的是1.8版本，所以默认ArrayList arrayList = new ArrayList();后，size应该是0.所以,size+1对扩容来讲很必要.

 

手写ArrayList，缩减版

/**
 * @program: IdeaJava
 * @Date: 2020/1/7 15:13
 * @Author: lhh
 * @Description:
 */
public class MyArrayList {

    transient Object[] elementData;

    private static final int DEFAULT_CAPACITY = 10;

    private static final Object[] EMPTY_ELEMENTDATA = {};

    private int size;

    public MyArrayList(int initialCapacity)
    {
        if(initialCapacity > 0)
        {
            this.elementData = new Object[initialCapacity];
        }else if (initialCapacity == 0)
        {
            this.elementData = EMPTY_ELEMENTDATA;
        }else
        {
            throw new IllegalArgumentException("Illegal Capacity: "+
                    initialCapacity);
        }
    }

    public MyArrayList()
    {
        this(DEFAULT_CAPACITY);
    }

    private void ensureExplicitCapacity(int minCapacity)
    {
        if(size == elementData.length)
        {
            int oldCapacity = elementData.length;
            int newCapacity = oldCapacity + (oldCapacity >> 1);
            if (newCapacity - minCapacity < 0)
            {
                newCapacity = minCapacity;
            }
            Object[] objects = new Object[newCapacity];
            System.arraycopy(elementData,0,objects,0,elementData.length);
            elementData = objects;
        }
    }

    public void add(Object o)
    {
        ensureExplicitCapacity(size + 1);
        elementData[size++] = o;
    }

    public void add(int index ,Object o)
    {
        rangeCheck(index);
        ensureExplicitCapacity(size + 1);
        System.arraycopy(elementData,index,elementData,index+1,size-index);
        elementData[index] = o;
        size++;
    }

    private void rangeCheck(int index)
    {
        if (index >= size)
            throw new IndexOutOfBoundsException("下标越界");
    }

    public Object get(int index)
    {
        rangeCheck(index);
        return elementData[index];
    }

    public Object remove(int index)
    {
        rangeCheck(index);
        Object oldValue = elementData[index];

        int numMoved = size - index - 1;
        if(numMoved > 0)
            System.arraycopy(elementData,index+1,elementData,index,numMoved);
        elementData[--size] = null;

        return oldValue;
    }

    public boolean remove(Object o)
    {
        for(int index = 0;index < size;index++)
        {
            if(o.equals(elementData[index]))
            {
                remove(index);
                return true;
            }
        }
        return false;
    }
    
    public int getSize()
    {
        return size;
    }
}