ArrayList 源码分析

ArrayList：

  ArrayList 类是一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素。

---

继承与接口图：

         它继承于AbstractList，实现了List, RandomAccess, Cloneable, java.io.Serializable这些接口。
ArrayList 继承了AbstractList，实现了List。它是一个数组队列，提供了相关的添加、删除、修改、遍历等功能。
        ArrayList 实现了RandmoAccess接口，即提供了随机访问功能。RandmoAccess是java中用来被List实现，为List提供快速访问功能的。在ArrayList中，我们即可以通过元素的序号快速获取元素对象；这就是快速随机访问。稍后，我们会比较List的“快速随机访问”和“通过Iterator迭代器访问”的效率。
        ArrayList 实现了Cloneable接口，即覆盖了函数clone()，能被克隆。
        ArrayList 实现java.io.Serializable接口，这意味着ArrayList支持序列化，能通过序列化去传输。和Vector不同，ArrayList中的操作不是线程安全的！所以，建议在单线程中才使用ArrayList，而在多线程中可以选择Vector或者CopyOnWriteArrayList。

---

成员变量： 

静态变量：

 定义四个私有域的静态的不可更改的属性

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 = {};  //用于默认大小的空实例的共享空数组实例。我们将其与空_ELEMIENTDATA区分开来，以了解在添加第一个元素时应该膨胀多少。

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8; // 容量最大值

 不会被实例化的成员变量

transient Object[] elementData;   // 存储ArrayList的元素，容量大小等于其长度

私有变量 ：

private int size;   //  ArrayList的大小(它包含的元素数)。

---

构造方法：

     // 构造器  initialCapacity 传0 默认为10 
     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);
        }
    }


    // 如果没有传值就将数组赋为定义好的空数组
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
    

    // 传泛型 继承自ArrayList<E>的实例 
    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();  // 变成数组元素传入
        if ((size = elementData.length) != 0) {  // 判断长度是否为0
            if (elementData.getClass() != Object[].class)  // 如果类型不相等，就用Arrays创建
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {     
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;   长度为0 返回空数组
        }
    }

ArrayList的扩容机制：

        ArrayList发生扩容无疑是因为在我们加入了元素，是得ArrayList的大小发生变化，因此我们首先看add方法的源码。

    // 添加
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // 判断是否扩容
        elementData[size++] = e;
        return true;
    }


    // 在指定位置插入  将插入位置向后复制
    public void add(int index, E element) {
        rangeCheckForAdd(index);

        ensureCapacityInternal(size + 1);  // Increments modCount!!
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }

     
    private void ensureCapacityInternal(int minCapacity) {   
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { 
        // 数组如果是空，比较minCapacity和DEFAULT_CAPACITY 取最小 创建数组大小
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }


    private void ensureExplicitCapacity(int minCapacity) {
         // Fail-Fast 机制 记录修改次数，最后和一个值相比，如果不同表示被修改，快速结束
        modCount++;    

       // 比较数组长度和需要的最小长度，如果数组长度大，不需要扩容，否则调用grow方法进行扩容
        if (minCapacity - elementData.length > 0) 
            grow(minCapacity);
    }

    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;   // 将原数组大小记录
        // 计算新数组大小 似为 newCapacity的大小为oldCapacity的1.5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1); 
        if (newCapacity - minCapacity < 0)  
            // 如果新数组大小还不够用，不在扩容，直接用 传进来的数组长度最小值
            newCapacity = minCapacity;
        // 如果新数组大小数 超过了 最大值 调用hugeCapacity方法 
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
     
        elementData = Arrays.copyOf(elementData, newCapacity); // 将数组复制
    }


    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // 数组需要的最小长度 < 0 直接抛异常
            throw new OutOfMemoryError();
        // 如果需要的最小长度超过最大值 传Integer.MAX_VALUE ，否则传MAX_ARRAY_SIZE
        return (minCapacity > MAX_ARRAY_SIZE) ?  
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

    

        从上述源码分析中，我们可以看到ensureCapacityInternal，ensureExplicitCapacity， grow这三个方法一起实现了ArrayList的扩容。其实现过程可以概述为：

        首先先判断elementData是不是DEFAULTCAPACITY_EMPTY_ELEMENTDATA，如果是并且elementData的大小要小于ensureCapacityInternal传入的整型数，则elementData的大小就不会改变，保持default capacity的大小为10；反之如果大小超出了10，则会调用grow方法，在grow方法中实现了ArrayList的扩容，>>1是位运算，即将oldCapacity的二进制值右移动一位，低位擦除，高位补零，该表达式可以近似为 newCapacity的大小为oldCapacity的1.5倍，也就是说当容量大于10的时候，ArrayList将以1.5倍的速度扩容。

fail-fast:

        采用安全失败机制的集合容器,在遍历时不是直接在集合内容上访问的,而是先copy原有集合内容,在拷贝的集合上进行遍历。在每次进行增删改时，modCount都会++，这个modCount是继承抽象类AbstractList类的。

        在遍历该集合元素时，同时执行修改或删除操作，并不影响集合遍历的完成和进行，遍历出的结果是未执行修改或删除操作的原集合元素。

 

 ，   迭代器迭代过程中，通过hasNext()方法，判断是否有下一个元素，如果返回true，就调用next()方法，继续迭代，当modCount != expectedModCount时，就会抛出该异常。

使用场景：

        区别于数组的功能，ArrayList不光实现了动态地存储元素，还提供了很多方便简单地方法，如增加元素，删除元素，得到元素索引等，而调用这些方法就免去了使用数组时的循环遍历，减少了时间复杂度和占用的内存。特别是要对大数据量进行插入，删除的操作时，ArrayList就会显示出明显的优势。

        ArrarList实现了泛型，不光可以存储基本类型的数据，还可以存储我们自己定义的类，这给我们开发提供了极大的方便，尤其当我们需要对很多个类进行操作时。例如对多个对象加线程，我们就不需要同时创建多个对象，对每一个对象都加上一个线程，那会使程序及其卡顿。因此我们可以创建一个ArrayList对象，将其他对象添加到ArrayList中去，对ArrayList对象添加线程就可以实现同样的效果，并且减少卡顿。

        注意, 对于整数、浮点和字符串的可调整大小的列表, 可以使用 IntList、FloatList 和 StringList 的处理类。