ArrayList底层实现和原理分析

ArrayList底层实现和原理分析

今天是周末，没什么事就在家里看了一下源码，我习惯使用Jdk1.8,所以我的代码全都是基于Jdk1.8，好了下面是正文，今天来说说ArrayList的底层实现和源代码。
首先，集合ArrayList是List的实现类，List还有两个实现类LinkedList和Vector。
先说说这几个实现类的区别吧：
1.首先在底层实现上ArrayList和Vector是基于数组实现的，在源代码中都维护了一个数组用于对数组进行操作，LinkedList底层维护的是链表；
2.类的继承路径不同，这里不多说继承路径了；
3.ArrayList线程不安全；其余两种线程安全
关于查询的速度：
ArrayList的查询速度快，LinkedList的增删改速度快；Vector因为是线程安全的所以它的查询速度也是很慢的；（原因在源代码中解释）

下面开始看代码：
首先：ArrayList提供了三个构造方法：
1.定义初始容量的集合

    /**
     * 定义了初始容量为10的Array List
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    /**
     * 可以自己定义创建集合的容量
     *
     */
    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(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

以上就是三种ArrayList的构造方法逻辑简单，代码简明就不做解释了，给个总结，这三个构造方法就是初始化一个存储数据的容器，其核心就是一个数组，也就是上面的elementData。

下面来看看ArrayList提供的方法：
首先要先解释下ArrayList中的扩容方法：

private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

private static int calculateCapacity(Object[] elementData, int minCapacity) {
   
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
   
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

private void ensureExplicitCapacity(int minCapacity) {
   
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

    private void grow(int minCapacity) {
   
        // 原数组长度
        int oldCapacity = elementData.length;
        //将数组长度扩容至原先的1.5倍>>1 右移一位相当于除以2， 左移一位相当于乘以2
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //新长度小于元素个数，则将新长度变为元素个数
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        //这是超限情形，即当新长度大于int最大值-8，则新长度为int最大值，hugeCapacity(minCapacity)实现不粘贴了，可以自己去源码中看
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);