ArrayList 源码分析-----扩容机制

最新推荐文章于 2024-08-07 16:14:14 发布

chao430

最新推荐文章于 2024-08-07 16:14:14 发布

阅读量436

点赞数 2

分类专栏： Collection

本文链接：https://blog.csdn.net/chao430/article/details/95398204

版权

Collection 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

Jdk1.7之前ArrayList默认大小是10，JDK1.7之后是0，JDK差异，每次约按1.5倍扩容。

动态扩容最关键是grow()方法。

通过源码中int newCapacity = oldCapacity + (oldCapacity >> 1);可得容量扩大为原来的1.5倍。
总之，ArrayList默认容量是10，如果初始化时一开始指定了容量，或者通过集合作为元素，则容量为指定的大小或参数集合的大小。每次扩容为原来的1.5倍，如果新增后超过这个容量，则容量为新增后所需的最小容量。如果增加1.5倍后的新容量超过限制的容量，则用所需的最小容量与限制的容量进行判断，超过则指定为Integer的最大值，否则指定为限制容量大小。然后通过数组的复制将原数据复制到一个更大(新的容量大小)的数组。

MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8
一个数组对象，例如int类型，和一个标准的java对象很类似。主要的区别在于：数组对象有一个用来存储数据大小的额外元数据片。一个数组对象的metadata包括：
①Class：指向类信息的指针用来表名对象类型。如整形数组，这个指针就指向int[]类；
②Flags：一个表示对象状态的flags集合，包括对象的hashcode（如果有的话）和对象的判断（表示一个对象是否是数组）；
③Lock：对象的同步信息，表明对象当前是否被synchronized；
④Size：数组的大小。
整型的最大值为2^31 = 2,147,483,648，因为数组本身需要8 bytes来存储大小2,147,483,648，因此数组的最大值为2^31-8。

首先来看看add()方法

 /**
     * 将指定的元素追加到此列表的末尾。 
     */
    public boolean add(E e) {
   //添加元素之前，先调用ensureCapacityInternal方法
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //这里看到ArrayList添加元素的实质就相当于为数组赋值
        elementData[size++] = e;
        return true;
    }

可以看到 add 方法首先调用了ensureCapacityInternal(size + 1)

//得到最小扩容量
    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
              // 获取默认的容量和传入参数的较大值
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
 
        ensureExplicitCapacity(minCapacity);
    }

当要 add 进第1个元素时，minCapacity为1，在Math.max()方法比较后，minCapacity 为10。

如果调用 ensureCapacityInternal() 方法就一定会（执行）这个方法ensureExplicitCapacity() 方法，下面我们来研究一下这个方法的源码！

 //判断是否需要扩容
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
 
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            //调用grow方法进行扩容，调用此方法代表已经开始扩容了
            grow(minCapacity);
    }

我们来仔细分析一下：

当我们要 add 进第1个元素到 ArrayList 时，elementData.length 为0 （因为还是一个空的 list），因为执行了 ensureCapacityInternal() 方法，所以 minCapacity 此时为10。此时，minCapacity - elementData.length > 0 成立，所以会进入 grow(minCapacity) 方法。
当add第2个元素时，minCapacity 为2，此时e lementData.length(容量)在添加第一个元素后扩容成 10 了。此时，minCapacity - elementData.length > 0 不成立，所以不会进入（执行）grow(minCapacity) 方法。
添加第3、4···到第10个元素时，依然不会执行grow方法，数组容量都为10。

直到添加第11个元素，minCapacity(为11)比elementData.length（为10）要大。进入grow方法进行扩容。

`grow()` 方法

 /**
     * 要分配的最大数组大小
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
 
    /**
     * ArrayList扩容的核心方法。
     */
    private void grow(int minCapacity) {
        // oldCapacity为旧容量，newCapacity为新容量
        int oldCapacity = elementData.length;
        //将oldCapacity 右移一位，其效果相当于oldCapacity /2，
        //我们知道位运算的速度远远快于整除运算，整句运算式的结果就是将新容量更新为旧容量的1.5倍，
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //然后检查新容量是否大于最小需要容量，若还是小于最小需要容量，那么就把最小需要容量当作数组的新容量，
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
       // 如果新容量大于 MAX_ARRAY_SIZE,进入(执行) `hugeCapacity()` 方法来比较 minCapacity 和 MAX_ARRAY_SIZE，
       //如果minCapacity大于最大容量，则新容量则为`Integer.MAX_VALUE`，否则，新容量大小则为 MAX_ARRAY_SIZE 即为 `Integer.MAX_VALUE - 8`。
        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);
    }

int newCapacity = oldCapacity + (oldCapacity >> 1),所以 ArrayList 每次扩容之后容量都会变为原来的 1.5 倍！记清楚了！不是网上很多人说的 1.5 倍+1！

">>"（移位运算符）：>>1 右移一位相当于除2，右移n位相当于除以 2 的 n 次方。这里 oldCapacity 明显右移了1位所以相当于oldCapacity /2。对于大数据的2进制运算,位移运算符比那些普通运算符的运算要快很多,因为程序仅仅移动一下而已,不去计算,这样提高了效率,节省了资源　

我们再来通过例子探究一下grow() 方法：

当add第1个元素时，oldCapacity 为0，经比较后第一个if判断成立，newCapacity = minCapacity(为10)。但是第二个if判断不会成立，即newCapacity 不比 MAX_ARRAY_SIZE大，则不会进入 hugeCapacity 方法。数组容量为10，add方法中 return true,size增为1。
当add第11个元素进入grow方法时，newCapacity为15，比minCapacity（为11）大，第一个if判断不成立。新容量没有大于数组最大size，不会进入hugeCapacity方法。数组容量扩为15，add方法中return true,size增为11。
以此类推······

最后看下jdk1.6的扩容机制：

public void ensureCapacity(int minCapacity) {  
    modCount++;  
    int oldCapacity = elementData.length;  
    if (minCapacity > oldCapacity) {  
        Object oldData[] = elementData;  
        int newCapacity = (oldCapacity * 3)/2 + 1;  //没有考虑整形溢出问题
        if (newCapacity < minCapacity)  
            newCapacity = minCapacity;  
        // minCapacity is usually close to size, so this is a win:  
        elementData = Arrays.copyOf(elementData, newCapacity);  
    }  
}

int newCapacity = (oldCapacity * 3)/2 + 1;和oldCapacity+(oldCapacity>>1);效果是一样的，都相当于1.5倍，但实际上有很大区别：①前者的乘除运算数学结果比后者大1，如oldCapaticy=10时，前者是16，后者是15；②在oldCapacity比较大时运算结果不一样，如oldCapacity=Integer.MAX_VALUE即10^9，前者算出-647483647，后者算出1500000000.
因此1.7及以上版本jdk对这两个问题做了修改：

参考:https://blog.csdn.net/qq_34337272/article/details/82766904

https://blog.csdn.net/JAVA528416037/article/details/78438815