Java面试重点--证明采用ArrayList有参构造器的扩容机制

我会带着你远行 2024-04-03 09:44 71阅读 0赞

### 上一篇链接：[Java面试重点–ArrayList 底层结构和证明采用Arraylist无参构造器的扩容机制][Java_ArrayList _Arraylist] ###

### 采用ArrayList有参构造器的扩容机制结论 ###

1、ArrayList的底层结构是一个Object\[\] elementData，即一个Object类型的数组。  
2、如果采用的是有参构造器，则数组初始空间为传入的参数值，如需再次扩容，则扩容至原数组空间的1.5倍。

### ArrayList 底层源码分析 ###

##### 证明采用Arraylist无参构造器的扩容机制 #####

在ArrayList中加入20个元素，数组初始空间为8。

import java.util.ArrayList;
    
    public class Arraylist_ {
        
        public static void main(String[] args) {
        
            ArrayList arrayList = new ArrayList(8);
            for (int i = 1; i <= 20; i++) {
        
                arrayList.add(i);
            }
            System.out.println(arrayList);
        }
    }

###### 添加第9个元素 ######

1、Debug进入arrayList.add(i)；

public boolean add(E e) {
        
            modCount++;
            add(e, elementData, size);
            return true;
        }

i = 9，所以e = 9。modCount = 9，size = 8。  
2、Debug进入add(e, elementData, size);  
e = 9，s = 8，因为数组初始空间为8，所以elementData.length = 8，所以满足s == elementData.length。

private void add(E e, Object[] elementData, int s) {
        
            if (s == elementData.length)
                elementData = grow();
            elementData[s] = e;
            size = s + 1;
        }

3、Debug进入grow()  
size = 8

private Object[] grow() {
        
            return grow(size + 1);
        }

4、Debug再次进入grow()  
minCapacity = size + 1 = 9，elementData.length = 8，所以oldCapacity = 8，所以满足if条件，进入if语句。  
oldCapacity = 8，minCapacity - oldCapacity = 1，oldCapacity >> 1 = 4

private Object[] grow(int minCapacity) {
        
            int oldCapacity = elementData.length;
            if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        
                int newCapacity = ArraysSupport.newLength(oldCapacity,
                        minCapacity - oldCapacity, /* minimum growth */
                        oldCapacity >> 1           /* preferred growth */);
                return elementData = Arrays.copyOf(elementData, newCapacity);
            } else {
        
                return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];
            }
        }

5、Debug进入newLength方法  
oldLength = 8，minGrowth = 1，prefGrowth = 4，所以newLength = prefGrowth + oldLength = 12，满足if条件，返回12，所以newCapacity = 12。

public static int newLength(int oldLength, int minGrowth, int prefGrowth) {
        
            // assert oldLength >= 0
            // assert minGrowth > 0
    
            int newLength = Math.max(minGrowth, prefGrowth) + oldLength;
            if (newLength - MAX_ARRAY_LENGTH <= 0) {
        
                return newLength;
            }
            return hugeLength(oldLength, minGrowth);
        }

6、返回grow()方法，执行return elementData = Arrays.copyOf(elementData, newCapacity);，进行数组的拷贝，所以elementData数组扩容至12，所以证明了创建ArrayList对象时，如果采用的是有参构造器，如需再次扩容，则扩容至原数组空间的1.5倍。

[Java_ArrayList _Arraylist]: https://blog.csdn.net/programmerchiu/article/details/127174125?spm=1001.2014.3001.5502