Java集合：ArrayList源码分析

其实我看到已有很多大佬写过此类文章，并且写的也比较清晰明了，那我为何要再写一遍呢？其实也是为了加深本身的印象，巩固本身的基础

（主要是不少文章没有写出来我想知道的东西！！！​！！！！)

---

前言 

我说一下我认为怎么样才能去看懂，看透彻一个源码。

在你去分析源码的时候，首先要会用，要明白这个工具类的做用，若是连一个工具类都包含哪些功能，这些功能的做用都不清楚，我以为看源码就是一种煎熬。（固然，大佬除外）

​自我洗脑中～我是大佬！我是大佬！我是大佬！（he~tui！我不配!!!）

---

正文

本次是基于JDK1.8来具体分析ArrayList源码

ArrayList的概念：

动态数组，它提供了动态的增长和减小元素，实现了Collection和List接口，灵活的设置数组的大小等好处。

每一个 ArrayList 实例都有一个容量。该容量是指用来存储列表元素的数组的大小。它老是至少等于列表的大小。随着向 ArrayList 中不断添加元素，其容量也自动增加。

一、继承结构分析

咱们先来看一下ArrayList类的继承结构：

​

Java支持单继承，多实现

AbstractList<E>：

抽象接口类，目的是使用抽象类中已经实现的方法。

咱们点开AbstractList<E>源码，会看到其实AbstractList<E>已经也实现了List<E>接口，为何要先继承AbstractList<E>，而让AbstractList先实现List<E>？而不是让ArrayList直接实现List<E>？

这里是有一个思想，接口中全都是抽象的方法，而抽象类中能够有抽象方法，还能够有具体的实现方法，正是利用了这一点，让AbstractList<E>实现接口中一些通用的方法，而如ArrayList就继承这个AbstractList类，拿到一些通用的方法，而后本身在实现一些本身特有的方法，这样一来，让代码更简洁，就继承结构最底层的类中通用的方法都抽取出来，先一块儿实现了，减小重复代码。因此通常看到一个类上面还有一个抽象类，应该就是这个做用。

List<E>：

使用List的接口规范

RandomAccess：

这个是一个标记性接口，经过查看api文档，它的做用就是用来快速随机存取，有关效率的问题，在实现了该接口的话，那么使用普通的for循环来遍历，性能更高，例如arrayList。而没有实现该接口的话，使用Iterator来迭代，这样性能更高，例如linkedList。因此这个标记性只是为了让咱们知道咱们用什么样的方式去获取数据性能更好。

Cloneable：

目的是使用clone方法。 想具体了解此方法的，点击这里，这篇文章写的仍是不错的Cloneable~~

Serializable：

实现该序列化接口，代表该类能够被序列化，什么是序列化？简单的说，就是可以从类变成字节流传输，而后还能从字节流变成原来的类。

🤔🤔🤔🤔为何AbstractList已经实现了List，ArrayList还要再实现一次呢？ 

• 其实ArrayList再去实现一次List在这里并无什么实际意义，这实际上是一个错误，由于做者写这代码的时候以为这个会有用处，可是其实并没什么用，但由于没什么影响，就一直留到了如今。有兴趣的同窗能够去研究一下。

二、类分析 

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

    /**
     * 实际数组的大小
     */
    private int size;

    /**
     * 数组的最大容量
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

这里分析几个地方：

（1）为何数组最大容量是Integer.MAX_VALUE - 8，而不是Integer.MAX_VALUE？

其实源码中给了备注：意思应该是有些虚拟机在数组中保留了一些头信息。避免内存溢出！

/**
     * The maximum size of array to allocate.
     * Some VMs reserve some header words in an array.
     * Attempts to allocate larger arrays may result in
     * OutOfMemoryError: Requested array size exceeds VM limit
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

（2）为何定义了两个空数组？

首先定义空数组的根本缘由是 优化处理，若是一个应用中有不少这样ArrayList空实例的话，就会有不少的空数组，无疑是为了优化性能，全部ArrayList空实例都指向同一个空数组。二者都是用来减小空数组的建立，全部空ArrayList都共享空数组。二者的区别主要是用来起区分做用，针对有参无参的构造在扩容时作区分走不一样的扩容逻辑，优化性能。

（3）elementData为何定义成transient？

具体缘由看这里： elementData定义为transent的缘由

三、构造方法

​

Array List总共有三个构造方法，下面咱们一一分析

1）无参构造方法 ArrayList()

/**
     * 将空数组初始化大小为10(将空数组初始化大小为10，具体在何时初始化大小为10，待会儿会说到)
     */
    public ArrayList() {
        // 将elementData元素数组初始化为空数组
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

无参构造方法中，将元素数组elementData初始化为空数组。(注意：这里就体现了我上文说到的，为何定义两个空数组)

2）有参构造方法 ArrayList(int)

/**
     * 构造一个具备指定初始容量的列表
     *
     * @param  initialCapacity: 初始化数组的值
     */
    public ArrayList(int initialCapacity) {
        //若是初始化的值大于0，则给定elementData一个长度为initialCapacity的数组
        if (initialCapacity > 0) { 
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) { // 若是初始化的值等于0，则初始化为空数组
            this.elementData = EMPTY_ELEMENTDATA;
        } else { //不然（小于0的状况）抛出异常
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

3）有参构造方法 ArrayList(Collection<? extends E> c)

/**
     * 构造一个指定元素的集合(此方法不太经常使用)
     * @param c 
     */
    public ArrayList(Collection<? extends E> c) {
        // 将集合转换为数组并赋值给elementData
        elementData = c.toArray();
        // 若是集合的大小不为0
        if ((size = elementData.length) != 0) {
            // 若是转换后的数组不是泛型(object)，则须要用Arrays的工具转换一下为object数组(这里再也不对Arrays.copyOf展开论述)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else { // 不然初始化elementData为一个空数组
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

对于当前构造方法，我举个例子，更清晰明了

​

四、经常使用方法源码分析

boolean add(E e)

重中之重，ArrayList的核心奥秘！！！！

/**
     * 在数组中增长一个元素
     * @param e 元素对象
     */
    public boolean add(E e) {
        // 肯定内部容量是否够用，size是元素数组中数据的个数，由于要添加一个元素，因此size+1，先判断size+1的这个个数数组可否放得下，就在这个方法中去判断是否数组.length是否够用了。
        ensureCapacityInternal(size + 1); 
        // 将元素e赋值到elementData末尾
        elementData[size++] = e;
        return true;
    }

    // 此方法能够理解为中转计算
    private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        // 判断数组是否是空数组, 若是是空数组(此时minCapacity = 0 + 1 = 1)，就将minCapacity初始化为10，但此时仅仅是返回要初始化数组的大小，并无真正初始化数组为10
        // private static final int DEFAULT_CAPACITY = 10;
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            // Math.max(参数1，参数2)方法的意思是返回参数中最大的数，若是是空数组是，此时返回的是10
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        // 若是初始化的集合不是空，则返回元素数组的size + 1
        return minCapacity;
    }
    
    // 别担忧 我有奥妙全自动(奥妙洗衣粉～全国人民都知道～～)
    private void ensureExplicitCapacity(int minCapacity) {
        // 结构变化记录+1 在父类AbstractList中定义了一个int型的属性：modCount，记录了ArrayList结构性变化的次数
        modCount++;
        
        // 判断数组是否够用，若是不够用，则自动扩容
        // 一、当初始化的集合为空数组时，此时minCapacity是10，而elementData的长度为0，因此须要扩容
        // 二、当初始化的集合不为空是，也就是给定了大小，或已经初始化了元素，此时的minCapacity = 实际数组个数+1，此时判断集合不够用，也须要进行扩容，不然元素会溢出
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

    // 自动扩容
    private void grow(int minCapacity) {
        // oldCapacity：元素数组的实际长度(即扩充前的数组大小)
        int oldCapacity = elementData.length;
        // oldCapacity 扩容1.5倍赋值给newCapacity( >>为右移运算符，至关于除以2 即oldCapacity/2 )
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        // 若是初始化为空的状况，则将数组扩容为10，此时才是真正初始化元素数组elementData大小为10
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        // 若是1.5倍的数组大小超过了集合的最大长度，则调用hugeCapacity方法，从新计算，也就是给定最大的集合长度
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // 已经肯定了大小，就将元素copy到elementData元素数组中~~
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

    private static int hugeCapacity(int minCapacity) {
        // 内存溢出判断
        if (minCapacity < 0)
            throw new OutOfMemoryError();
        // 这里的逻辑为：若是须要扩容的大小比数组的最大值都大，就返回Integer,MAX_VALUE(int最大值),不然返回集合的最大值(int最大值-8)
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

void add(int index, E element)

增长元素到指定下标

/**
     * 增长元素到指定下标
     *
     * @param index 下标
     * @param element 元素
     */
    public void add(int index, E element) {
        // 参数校验
        rangeCheckForAdd(index);
        // 此方法再也不赘述，参考上文Add方法重的论述
        ensureCapacityInternal(size + 1);
        // 请看下面代码块的注释
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        // 将指定元素覆盖到指定下标
        elementData[index] = element;
        // 长度size + 1
        size++;
    }

    /**
     * 适用于add 和 addAll的校验方法
     */
    private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

System.arraycopy 方法解析

/**
     * System提供了一个静态方法arraycopy(),咱们可使用它来实现数组之间的复制
     * 函数为：public static native void arraycopy(Object src,int srcPos,Object dest, int destPos,int length)；
     * @param      src      the source array. 源数组
     * @param      srcPos   starting position in the source array. 源数组的起始位置
     * @param      dest     the destination array. 目标数组
     * @param      destPos  starting position in the destination data. 目标数组的起始位置
     * @param      length   the number of array elements to be copied. 复制的长度
         
    //举个例子
    public static void main(String[] args){

        int[] arr = {1,2,3,4,5};
        int[] copied = new int[10];
        System.out.println(Arrays.toString(copied));

        System.arraycopy(arr, 0, copied, 1, 5);//5是复制的长度

        System.out.println(Arrays.toString(copied));

    }
   输出结果为：
    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    [0, 1, 2, 3, 4, 5, 0, 0, 0, 0]

boolean remove(Object o)

根据元素进行删除

public E remove(int index) {
        // 参数校验
        rangeCheck(index);
        // 结构变化记录+1
        modCount++;
        // 获取旧数据，返回给开发人员，目的是让开发人员知道删除了哪一个数据
        E oldValue = elementData(index);
        // 计算须要元素须要移动的次数
        int numMoved = size - index - 1;
        if (numMoved > 0)
            // 同上文叙述
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        // 将最后一个元素置为空(元素前移，最后一位置为空)，让GC回收
        elementData[--size] = null;

        return oldValue;
    }

     private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

void clear()

清空集合

/**
     * 清空集合
     */
    public void clear() {
        modCount++;

        // 将数组置为空，促使GC回收
        for (int i = 0; i < size; i++)
            elementData[i] = null;

        size = 0;
    }

E get(int index)

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

/**
     * 检查给定的索引是否在范围内。 若是没有，则抛出一个适当的运行时异常。
     * @param index : 下标
     */
    public E get(int index) {
        // 校验下标有效性
        rangeCheck(index);
        // 返回元素数组中指定index位置的数据
        return elementData(index);
    }
 
   
    private void rangeCheck(int index) {
        // 若是下标大于实际数组长度（元素数组最后一个数据下标为size-1）
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

E set(int index, E element) 

/**
     * 覆盖相应下标的数据
     * @param index 下标
     * @param element 元素数据
     */
    public E set(int index, E element) {
        // 校验方法(再也不解释，与get方法中同样)
        rangeCheck(index);
        // 获取到旧数据，这里将旧数据返回出去，为了让开发者知道替换的是哪一个值
        E oldValue = elementData(index);
        // 将指定下标覆盖为新元素
        elementData[index] = element;
        return oldValue;
    }

---

结尾

其实ArrayList中还有不少不少方法，这里就不在一一叙述了，由于你理解了本文中所说的源码，其实其它再去理解，再去查看，是比较容易简单的。

​

本篇文章就讲到这里，若是有写的很差的地方，请多多指教，我是善良的小黑哥，但愿与你们共同进步！！