ArrayList的源码阅读

说明：本次ArrayList的源码阅读是基于 jdk1.8

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

    /**
     * Default initial capacity.  默认初始容量 = 10
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * 如果容量为0的时候，就返回这个数组
　　　*/

    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.
　　　*  使用默认容量 10 的时候，使用这个数组
     */
    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.
　　　*  list 真正存储数据的地方
     */
    transient Object[] elementData; // non-private to simplify nested class access

　　//修改次数

　　　protected transient int modCount = 0;

/**
　　　* 数组长度 即 list的长度   
     * The size of the ArrayList (the number of elements it contains) 
    */
    private int size;

　　
　　// 无参构造函数：空数组

　　public ArrayList() {
　　　　    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
　　}
　　
　　//有参构造    initialCapacity   初始容量

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);
    }



 //参数为 Collection  的构造函数

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有三个构造方法，不同的构造方法的容量是不一样的，具体可以查看JDK 源码。

如果不传入初始容量，就使用默认容量，并设置elementData为DEFAULTCAPACITY_EMPTY_ELEMENTDATA
如果传入初始容量，会判断这个传入的值，如果大于0，就new一个新的Object数组，如果等于0，就直接设置elementData为EMPTY_ELEMENTDATA。
如果传入一个Collection，则会调用toArray()方法把它变成一个数组并赋值给elementData。同样会判断它的长度是否为0，如果为0，设置elementData为EMPTY_ELEMENTDATA

ArrayList的 add、remove、set、get实际上是对数组的操作；真正有特殊的操作是 add方法，add方法可能涉及到数组的扩容

什么是扩容？

　　ArrayList有 2个概念，DEFAULT_CAPACITY 初始容量，其实质是数组elementData的长度。而size则表示的“存放的元素的个数”。
　　　

　　ArrayList的add 方法：

 public boolean add(E e) {
　　　　　//执行新增逻辑
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

    private void ensureCapacityInternal(int minCapacity) {
　　　　　　// 如果 此时的list数组 elementData 是空数组，求 要扩容后的 数组的长度 minCapacity 为  默认容量和 minCapacity中的最大值 
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
　　　　　//执行
        ensureExplicitCapacity(minCapacity);
    }


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

        // overflow-conscious code
　　　　　// 如果此时 加1后的数组长度 大于 此时 elementData数组的 长度，执行 扩容
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;  //原数组的容量
        int newCapacity = oldCapacity + (oldCapacity >> 1);// 扩容为原来容量的1.5倍 ，>> 右位移运算符，把符号左边的数据除以2的1（符号右边数据）次幂；    
        if (newCapacity - minCapacity < 0) //如果新容量仍然小于期望容量

            newCapacity = minCapacity;  //使用期望容量
        if (newCapacity - MAX_ARRAY_SIZE > 0)// 如果期望容量大于 数组最大容量
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);//数组扩容
    }

// 处理数组最大值， 防止数组下标越界，  最大值为  Integer.MAX_VALUE
private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

可以看到，底层其实是调用了Arrays.copyOf方法来进行扩充数组容量的。这里我们主要看一下最后一个方法newCapacity(int minCapacity)的实现。

默认情况下，新的容量会是原容量的1.5倍，这里用了位运算提高效率。一般情况下，如果扩容1.5倍后就大于期望容量，那就返回这个1.5倍旧容量的值。而如果小于期望容量，那就返回期望容量。这里对默认容量10做了特殊处理。

使用1.5倍这个数值而不是直接使用期望容量，是为了防止频繁扩容影响性能。试想如果每次add操作都要扩容一次，那性能将会非常低下。

常见问题汇总

ArrayList的默认初始长度是多少？最大长度是多少？

　　　　ArrayList的默认初始长度是10，是由DEFAULT_CAPACITY设定的。

　　　　由于ArrayList底层是用Object数组存储元素，所以ArrayList最大长度为Integer.MAX_VALUE，即2147483647(2)。这里需要注意常量MAX_ARRAY_SIZE(Integer.MAX_VALUE - 8)并不是ArrayList真正的最大长度，原因可以参考hugeCapacity()方法。

ArrayList是如何扩容的？

扩容发生在插入数组元素时（关键方法为grow()方法）

　　先计算增加完新元素后的ArrayList长度size
　　然后size与minCapacity比较来判断是否需要扩容
　　扩容时一般扩容为新数组长度newCapacity为原数组长度oldCapacity的1.5倍（oldCapacity带符号右移1位并加上oldCapacity）。
　　特殊情况是存在newCapacity长度超过Array的最大支持长度MAX_ARRAY_SIZE则调用hugeCapacity()进行特殊处理防止数组超出最大长度(int最大值)。

ArrayList扩容后是否会自动缩容？如果不能怎样进行缩容？

　　ArrayList只能自动扩容，不能自动缩容。如果需要进行缩容，可以调用ArrayList提供的trimToSize()方法。调用remove方法，删除元素的时候，不会进行缩容操作，只进行数组的copy操作，空余出来的位置为null;

ArrayList底层数组扩容时是如何保证高效复制数组的？

　　表面上是调用Arrays.copyOf()方法，实际上是Arrays.copyOf()通过调用System.arraycopy()方法确保高效复制数组。

posted @ 2020-05-09 18:06 wl_王麟阅读(152) 评论(0) 编辑收藏举报

刷新页面返回顶部

wl_王麟

ArrayList的源码阅读

公告