关于Arraylist的扩容解析

Arraylist集合

注：部分图片来自b站韩顺平提供的文档，感谢韩大大

注意事项

常用方法

方法名	说明
boolean add(Object o)	在列表的末尾顺序添加元素，起始索引位置从0开始
void add(int index,Object o)	在指定的索引位置添加元素。索引位置必须介于0和列表中元素个数之间
int size()	返回列表中的元素个数
Object get(int index)	返回指定索引位置处的元素。取出的元素是Object类型，使用前需要进行强制类型转换
boolean contains(Object o)	判断列表中是否存在指定元素
boolean remove(Object o)	从列表中删除元素
Object remove(int index)	从列表中删除指定位置元素，起始索引位置从0开始

ArrayList 的底层操作机制源码分析

底层如何扩容

深入底层，理解Arraylist扩容

我们对如下代码进行debug

    public static void main(String[] args) {//干就完了
        ArrayList arrayList = new ArrayList();//
        arrayList.add(1);//第一次扩容 数组容量为10
        for (int i = 2; i < 11; i++) {
            arrayList.add(i);
        }
        arrayList.add(11);//看看第二次扩容（为原容量的1.5倍）
        for (Object o :arrayList) {
            System.out.println(o);
        }
    }

ArrayList arrayList = new ArrayList();//下断点

    public ArrayList() {//调用无参
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;//elementData为空
    }
private int size;//ArrayList的属性（表示容量大小）

    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    private static final int DEFAULT_CAPACITY = 10;

//此时 size=0
---------------------------------------------------------------------------------------
    
         arrayList.add(1);下断点
    
    
       public boolean add(E e) {//e-->1
           ensureCapacityInternal(size + 1);  // Increments modCount!!
           elementData[size++] = e;
           return true;
    }

    //进入到ensureCapacityInternal
    private void ensureCapacityInternal(int minCapacity) { //minCapacity=size + 1=1（也就是需要的最少容量）
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

    //我们先看一下calculateCapacity这个方法
 private static int calculateCapacity(Object[] elementData, int minCapacity) {//minCapacity=1
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {//通过无参构造elementData不为null 可知true
            //DEFAULT_CAPACITY是Arraylist的常量 值为10
            return Math.max(DEFAULT_CAPACITY, minCapacity);//返回最大值10
        }
        return minCapacity;
    }

    //进入到ensureExplicitCapacity
    private void ensureExplicitCapacity(int minCapacity) {//通过calculateCapacity方法知道参数minCapacity=10
        //此时需要的最少容量变为了10
        modCount++;//添加的次数

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)//10-0>0 true 也就是说当前数组的容量不满足所需的最少容量
            grow(minCapacity);//扩容
    }

    //进入到grow方法
    private void grow(int minCapacity) {//10
        // overflow-conscious code
        int oldCapacity = elementData.length;//存值  oldCapacity=0
        int newCapacity = oldCapacity + (oldCapacity >> 1);//这里是新的容量为原来的1.5倍
        //oldCapacity=0则newCapacity=0
        if (newCapacity - minCapacity < 0)//0-10<0 true
            newCapacity = minCapacity;//则新的容量就为10
        if (newCapacity - MAX_ARRAY_SIZE > 0)//MAX_ARRAY_SIZE是存装的最大容量 fals
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity（10）的新数组赋值给);
        //调用Arrays.copyOf方法实现数组（集合）的扩容， 
        //把elementData复制成长度为newCapacity（10）的新数组赋值给elementData
    }
    //至此完成数组的扩容
        arrayList.add(11);//增添第11个元素，也是走上面的方法  有一定的差别 但是大同小异不赘述