JDK1.8 ArrarList底层扩容机制

最新推荐文章于 2024-10-22 15:12:35 发布

岔路村花

最新推荐文章于 2024-10-22 15:12:35 发布

阅读量236

点赞数 1

分类专栏： java 文章标签： java

本文链接：https://blog.youkuaiyun.com/weixin_44144305/article/details/108628634

版权

java 专栏收录该内容

5 篇文章

订阅专栏

本文探讨了JDK1.8中ArrayList的扩容机制。在创建ArrayList实例时，默认分配一个空数组。首次调用add方法时，通过ensureCapacityInternal计算最小容量，若数组为空则设置为10。当元素数量超出容量，通过grow方法进行1.5倍扩容。总结来说，ArrayList初始容量为10，后续扩容按1.5倍进行。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

JDK1.8 ArrarList底层扩容机制

ArrayList list=new ArrayList();
list.add(1);

这里会调用ArrayList的空参构造方法

 /**
     * Constructs an empty list with an initial capacity of ten.
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

这里的DEFAULTCAPACITY_EMPTY_ELEMENTDATA是一个空的数组

   /**
     * Shared empty array instance used for default sized empty instances. We
     * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
     * first element is added.
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

elementData就是ArrayList底层用来存元素的数据

    /**
     * The array buffer into which the elements of the ArrayList are stored.
     * The capacity of the ArrayList is the length of this array buffer. Any
     * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
     * will be expanded to DEFAULT_CAPACITY when the first element is added.
     */
    transient Object[] elementData; // non-private to simplify nested class access

也就是说在new完ArrayList对象之后就会默认给elementData赋值一个空的元素数组

到这里new 就结束了，接下来看add

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

这里的ensureCapacityInternal就是Arraylist底层的扩容方法
因为是第一次add，在之前这个ArrayList里还没有元素，所以size=0，（size是ArrayList中元素的数量）

   private static int calculateCapacity(Object[] elementData, int minCapacity) {
       if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
           return Math.max(DEFAULT_CAPACITY, minCapacity);
       }
       return minCapacity;
   }

这个方法用来计算容量，里面进行了判断
如果数组为空，就返回10

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

点进去

    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

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

所以这里传入的minCapacity就是10，再点进这个grow方法

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);
    }