【java】ArrayList 源码分析

最新推荐文章于 2024-08-18 23:25:39 发布

Acyang_

最新推荐文章于 2024-08-18 23:25:39 发布

阅读量45

点赞数

文章标签： java 开发语言算法

本文链接：https://blog.csdn.net/qq_53138373/article/details/129759067

版权

ArrayList在Java中通过维护一个Object类型的elementData[]数组来存储元素。默认构造器创建时，数组初始容量为10，添加元素超过10会扩容至1.5倍。有参构造器可指定初始容量，当元素超出该容量时同样扩容1.5倍。文章详细分析了ArrayList的扩容过程和相关源码。

摘要由CSDN通过智能技术生成

先说结论，再分析源码

ArrayList底层维护了一个Object类型的elementData[]数组
ArrayList调用无参构造器创建对象时，会得到一个空数组对象elementData,添加第一个元素时会将elementData初始化容量为10，若后续添加元素数量超过10，为将其容量扩充1.5倍，即15；后面如果再超过时，又扩充为1.5倍，以此类推
ArrayList调用有参构造器创建对象，会传入一个整数，表示element数组的初始大小，如果添加元素超过该大小，会扩充容量到1.5倍，后面如果再超过最大容量，又扩充到1.5倍，以此类推

import java.util.ArrayList;
public class ArrayList_{
    public static void main(String[] args) {
        ArrayList list=new ArrayList();  
     
        for (int i=1;i<=15;i++){
            list.add(i);
        }

        for(int i = 16;i <= 30;i ++){
            list.add(i);
        }
        System.out.println(list);
    }
}

源码分析
ArrayList list=new ArrayList();
public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
通过默认构造器创建ArrayList对象时会进入以上代码，将对象的elementData赋值为空数组

list.add(i)；
当i = 1时，会进入
 public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // 这是确定数组容量的方法
        elementData[size++] = e;
        return true;
    }
我们进入ensureCapacityInternal方法
private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }
我们进入ensureExplicitCapacity方法
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;   //表示修改数组的次数，避免多个进程同时操作数组
        
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)  
            grow(minCapacity);
    }
  minCapacity是数组需要的最小容量，如果数组的大小小于minCapacity，就需要扩容，调用grow方法
 我们进入grow方法
  private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);  //将数组容量扩充为原来的1.5倍
        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);  //真正复制数组为原来的1.5倍容量
    }
 第一次添加时数组原大小为0，所以计算出的newCapacity也为0，此时0 - 10 < 0会进入  if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
 所以将数组的大小赋为minCapacity，即10，因此添加第一个元素时数组的初始大小为10
当以后再添加元素时，会判断需要的最小数组容量与数组实际容量比较，若前者较大，则需要扩充，调用grow方法；在grow方法里 通过int newCapacity = oldCapacity + (oldCapacity >> 1)计算出新数组的容量，即原数组的1.5倍，后面再复制更新了容量的数组;
当执行list.add(16)时，数组的容量扩充到22

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

调用指定容量的构造器：
    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);
        }
    }

判断输入的内容,>0则将该容量的数组对象赋给elementData, =0 则创建为空数组，< 0 则说明该容量不合法，后面的add()方法则与无参情况一样