ArrayList的扩容机制_arraylist扩容机制-CSDN博客

本文链接：https://blog.csdn.net/weixin_44359369/article/details/139159578

ArrayList的扩容机制

1.扩容机制

注意:没有缩容机制.移除元素时,只是修改size值以及把原有的元素的引用值指向null

1.ArrayList中维护了一个Object类型的数组elementData:

transient Object[] elementData;//transient:瞬间的,短暂的. 表示该属性不会被序列化

2.当创建ArrayList对象时,如果使用的是无参构造器,则初始elementData的容量为0,第一次添加(调用add方法),则扩容elementData为10,如果需要再次扩容则扩容elementData容量的1.5倍

3.如果使用的指定大小的构造器,则初始elementData容量为指定大小,如果需要扩容,则直接扩容elementData容量的1.5倍.

2.源码解读

2.1 构造器:

决定了elementData数组(Objecc类型)的初始大小:
无参构造器:

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;//默认是一个没有元素的数组
    }

有参构造器:

使用传入的数值作为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);
        }
    }

2.2 添加元素的方法**

add(Object e):

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

addAll(Collection<? extends E> c):

public boolean addAll(Collection<? extends E> c) {
        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  // Increments modCount
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
        return numNew != 0;
    }

add与addAll法添加元素时其实没有本质区别,步骤是相同的.

1.确定容量大小,容量充足,不做处理;容量补足触发扩容

2.追加传入的元素(add是单个,addAll是多个元素)到elementData数组中

3.更新size属性值(size是elementData存储元素的个数).

其实扩容机制几乎可以说跟StringBuffer的扩容机制一样

2.3.扩容机制以及一些问题思考**

无论是add还是addAll方法,设计到扩容的部分是一样的,都是都会掉用ensureCapacityInternal(int minCapacity)方法进行处理.

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

// calculateCapacity(elementData, minCapacity):minCapacity预处理,elementData为{}时,(无参构造或者有参构造传入0得到的ArrayList满足此条件),添加元素,会将添加元素的个数与默认容量(10)比较,选取最大值作为返回值传给ensureExplicitCapacity(int minCapacity)进一步处理;
//不为{}时,直接使用该值作为ensureExplicitCapacity(int minCapacity)入参进一步处理
 private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

//选取最大值作为返回值传给ensureExplicitCapacity(int minCapacity)
// 判断当前elementData的容量是否满足使用需要,不满足进行扩容操作
private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

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

//扩容操作:这个扩容操作几乎与StringBuffer一模一样.唯一区别在于StringBuffer的newCapacity是当前容量*2+2;ArrayList的newCapacity是1.5*当前容量
 private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 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);
    }
// 进一步判断:
private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

再次简单分析分析newCapacity是取 oldCapacity + (oldCapacity >> 1);还是minCapacity(size + numNew)(add方法,numNew=1;addAll方法是添加的集合元素的个数);以及最终的返回结果的取值(newCapacity或者minCapacity或其他);

下面分类讨论:

int newCapacity = oldCapacity + (oldCapacity >> 1);未溢出:

size + numNew未溢出:

size+numNew-elementData.length>0成立,触发扩容机制;

此时若newCapacity - minCapacity < 0成立,newCapacity 取minCapacity;

若newCapacity - minCapacity < 0不成立,newCapacity 取 oldCapacity + (oldCapacity >> 1);

不大于MAX_ARRAY_SIZE,取newCapacity ;大于取Integer.MAX_VALUE

size + numNew溢出:

size+numNew-elementData.length>0是否恒成立,从而会触发扩容机制?

为什么恒成立?证明如下:

size+numNew-elementData.length=numNew+(size-elementData.length);正+负,不会溢出

size+numNew-elementData.length=Integer.MAX_VALUE+c-elementData.length

c取值范围为[1,min(size,numNew);

正+正且不会溢出,所以大于0恒成立,会会触发扩容机制

再看扩容机制容量取值:

newCapacity - minCapacity =1.5elementData.length-(size+numNew)

=1.5elementData.length- Integer.MAX_VALUE-c

=0.5elementData.length-(Integer.MAX_VALUE+c-elementData.length)

c取值范围为[1,min(size,numNew);

正+负不会溢出.

显然:1.5elementData.length- Integer.MAX_VALUE-c<=Integer.MAX_VALUE- Integer.MAX_VALUE-c<=-1<0恒成立

newCapcity取oldCapacity值,

此时newCapacity-MAX_ARRAY_SIZE= Integer.MAX_VALUE+c-Integer. Integer.MAX_VALUE+8=8+c;

8+c范围为[9,(2/3)*Integer.Max_VALUE],大于0恒成立,调用hugeCapacity(newCapacity),抛出OutOfMemoryError

int newCapacity = oldCapacity + (oldCapacity >> 1);溢出:

size + numNew未溢出:

1.5elementData.length>Integer.MAX_VALUE=>elementData.length范围在[(2/3)*Integer.MAX_VALUE,Integer.MAX_VALUE];

newCapacity - minCapacity= 0.5elementData.length-(Integer.MAX_VALUE+c-elementData.length)

正加负不会溢出;

而原式子是负加负不会溢出,小于0恒成立,所以 newCapacity = minCapacity;

最终取minCapacity作为新数组容量。

size + numNew溢出:

不论二者谁溢出,最后都会因为溢出导致程序出现异常终止运行

其实这一块是存疑的,以下是我疑惑的点,如果有懂的大佬,欢迎在评论区解惑

newCapacity =1.5*Integer.MAX_VALUE
minCapacity=2*MAX_VALUE
显然newCapacity - minCapacity < 0
newCapacity 取2*MAX_VALUE
到下面的条件:
newCapacity - MAX_ARRAY_SIZE=2*MAX_VALUE-(MAX_VALUE-8)=MAX_VALUE+8其实是小于0.
也就是说会跳过hugeCapacity()方法的验证.直接运行:
 elementData = Arrays.copyOf(elementData, newCapacity);
虽然也会因为溢出传入一个负数导致copyOf方法报错.
但是显然没有StringBuffer的扩容严谨.不明白源码为什么会这样写.
另外,想通过创建两个容量为Integer.MAX_VALUE的list,调用addAll方法,debug一下,看看会不会跳过hugeCapacity方法,但是不知道为什么会出现
"Exception in thread "main" java.lang.OutOfMemoryError: Requested array size exceeds VM limit";
导致无法debug观察运行.

2.3 是否存在缩容机制

不存在.可以查看移除元素的代码:

这些方法只是把要移除的元素所指向的位置置空,但并没有对elementData的现有容量进行操作.

remove(int index) :

public E remove(int index) {
        rangeCheck(index);

        modCount++;
        E oldValue = elementData(index);

        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work

        return oldValue;
    }

remove(Object o):

 public boolean remove(Object o) {
        if (o == null) {
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);
                    return true;
                }
        } else {
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }

//  fastRemove(index);
 private void fastRemove(int index) {
        modCount++;
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work
    }

//

removeAll(Collection<?> c):

 public boolean removeAll(Collection<?> c) {
        Objects.requireNonNull(c);
        return batchRemove(c, false);
    }
 private boolean batchRemove(Collection<?> c, boolean complement) {
        final Object[] elementData = this.elementData;
        int r = 0, w = 0;
        boolean modified = false;
        try {
            for (; r < size; r++)
                if (c.contains(elementData[r]) == complement)
                    elementData[w++] = elementData[r];
        } finally {
            // Preserve behavioral compatibility with AbstractCollection,
            // even if c.contains() throws.
            if (r != size) {
                System.arraycopy(elementData, r,
                                 elementData, w,
                                 size - r);
                w += size - r;
            }
            if (w != size) {
                // clear to let GC do its work
                for (int i = w; i < size; i++)
                    elementData[i] = null;
                modCount += size - w;
                size = w;
                modified = true;
            }
        }
        return modified;
    }

clear():

public void clear() {
        modCount++;

        // clear to let GC do its work
        for (int i = 0; i < size; i++)
            elementData[i] = null;

        size = 0;
    }