Java-List-ArrayList的扩容机制

ArrayList扩容机制解析

最新推荐文章于 2025-09-05 20:08:02 发布

原创最新推荐文章于 2025-09-05 20:08:02 发布 · 777 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#java #list #链表

本文详细介绍了Java中ArrayList的扩容机制，包括ArrayList的基本特性、与LinkedList的区别、add过程中的Grow过程以及hugeCapacity(int minCapacity)方法。重点讨论了扩容时如何计算新容量，以及在不同情况下如何保证数组的健壮性和效率。通过理解这些机制，可以优化大量数据添加时的性能。

title: Java-List-ArrayList的扩容机制
date: 2021-09-22 14:45:06
tags: Java
categories:

Java
toc: true # 是否启用内容索引

ArrayList简介

继承AbstractList，ArrayList继承了AbstractList的功能和其抽象含义。

实现了List,RaddomAccess,Cloneable,Serializable

表示实现了集合,随机快速访问，克隆，序列化的功能和其抽象含义

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
  }

RandomAccess标识接口，表示实现类实现的List接口集合支持快速访问的。通过元素访问快速获取元素对象

实现了Cloneable接口，覆盖了函数的clone()，表示能被克隆，但只是浅克隆

Serializable接口意味着ArrayList支持序列化,能通过序列化去传输

List接口下的主要实现类

与Vector不同的是Vector实现类线程安全，它是古老的List实现类,效率没有ArrayList高

ArrayList线程不安全

与LinkedList的区别

1.都是线程不安全的

2.底层集合的数据结构不同,ArrayList底层是数组，而LinkedList底层是双向链表(JDK1.6之前是循环列表，JDK1.7以后是循环列表)

3.插入和删除是否受元素位置的影响：ArrayList采用数组存储，所以插入和删除元素的时间复杂度受位置的影响,因为是顺序关系.

而LinkedList则不同它的增删在任意位置下都为o(1)

所以ArrayList的增删慢，而LinkedList的增删快

4.LinkedList不支持高效的随机元素访问,而ArrayList支持。

5.内存占用，ArrayList会在结尾预留一定内容的容量空间,而LinkedList的空间花费在它的每一个元素都要消耗ArrayList更多的空间

add过程

1.判断是否需要扩容

2.然后对比是选用默认容量与最小容量之间那个小的容量

3.然后继续判断是否需要扩容，第一次的时候因为是空的所以添加第一个的时候就需要扩容然后elementData.length=10,当数组不为空的时候,方法里minCapacity的值为插入的索引值+1

4.与elementData.length进行对比，扩容扩充的就是elementData的容量长度

(向右移1位>> 等价于该数%2)

5.Grow方法为扩容方法,一般扩容后的容量,扩容扩充的是elementData的容量,Grow中

Grow过程

1.当前数组长度大小为容器的大小oldCapacity,通过位运算将oldCapacity扩容1.5倍为其新容量,

2.检查新容量,如果新容量<当前最小容量,则把最小容量当成数组的新容量(增强代码的健壮性)

3.如果newCapacity>minCapacity,则newCapacity=Integer.maxValue(0xffff)(0111 1111 1111 1111)

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

4.如果minCapacity大于最大容量，则新容量则为Integer.MAX_VALUE，否则，新容量大小则为 MAX_ARRAY_SIZE

if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);

扩容的位运算

int newCapacity = oldCapacity + (oldCapacity >> 1)

hugeCapacity(int minCapacity)方法

如果minCapacity大于最大容量则newCapacity=Integer.Max_VALUE,直接将新容量拉满

扩容机制总结：

当我们add(o)添加元素时,假设是添加第n个数,可能出现的扩容机制,扩容完毕修改elemtData[size++]对象的数据.因为是第n个数所以下标为n-1,而size=修改前的数据个数,所以size=n-1;修改完毕,集合个数+1,size+1;所以elemtData[size++];

扩容:

size->当前List的数量

minCapacity->size+1，为当前插入的是第几个个数。假如我们要插入的是第七个数，则minCapacity=7

第一步,ensureCapacityInternal(int minCapacity)方法,确定并得到最最小扩容量,看是默认容量还是minCapacity

modCount->是父类的私有对象,线程安全。表示List被修改的次数

第二步,ensureExplicitCapacity(int minCapacity),进入此方法,执行一次此方法（modCount+1）;表示此List修改次数+1。判断

当(minCapacity)->size+1>elementData.lenth时，扩容Grow(minCapacity)

第三步,grow(int minCapacity),进入此方法先定义一个newCapacity其elementData.length1.5倍大小,检查,如果newCapacity>MAX_ARRAY_SIZE->值为(0xffff-8);

则更新->newCapacity=hugeCapacity(minCapacity);

return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;

所以说minCapacity>MAX_ARRAY_SIZE,将newCapacity更新为Integer.MAX_VALUE,小于的话就为MAX_ARRAY_SIZE->值为(0xffff-8)

最后将返回到的newCapacity,变为elementData容量,然后拷贝出原elementData,容量为newCapacity的数组给elementData.

elementData = Arrays.copyOf(elementData, newCapacity);

Arrays静态方法->ArrayCopy

浅拷贝,

public static native void arraycopy(Object src,  int  srcPos,
        Object dest, int destPos,
        int length);

特别的一个,有很多重载

Arrays静态方法->CopyOf

浅拷贝

public static int[] copyOf(int[] original, int newLength)

特别的一个,有很多重载,表示调用System.arraycopy,将源数组中的数据进行拷贝,并返回新的数组,只能拷贝整形的数组

注意

在使用List接口对象添加大量数据时先使用ensureCapacity方法

可以减少重新分配的次数

public class EnsureCapacityTest {    
    public static void main(String[] args) {        
        ArrayList<Object> list = new ArrayList<Object>();        
        final int N = 10000000;        
        list = new ArrayList<Object>();        
        long startTime1 = System.currentTimeMillis();        
        list.ensureCapacity(N);        
        for (int i = 0; i < N; i++) {
            list.add(i);        
        }        
        long endTime1 = System.currentTimeMillis();        
        System.out.println("使用ensureCapacity方法后："+(endTime1 - startTime1));    
    }
}