Java ArrayList扩容机制原理深入分析

// 默认ArrayList底层数组长度为10

private static final int DEFAULT_CAPACITY = 10 ;

// 空数组  其他地方调用

private static final Object[] EMPTY_ELEMENTDATA = {};

// 默认长度的空数组

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

// elementData 真正存储数据的数组  ArrayList的容量就是该数组的长度

// 默认创建空的ArrayList将在第一次调用add方法时将该数组扩容成为DEFAULT_CAPACITY = 10的容量

transient Object[] elementData;

// size代表的是当前elementData数组中存储的元素个数  并不是数组的容量！

private int size;

ArrayList<> list = new ArrayList<>( 12 );

public ArrayList( int initialCapacity) {

     // initialCapacity就是你指定的长度

     // 逻辑判断

         if (initialCapacity > 0 ) {

// initialCapacity符合要求就创建新数组 长度为你指定的长度

             this .elementData = new Object[initialCapacity];

         } else if (initialCapacity == 0 ) {

// 如果initialCapacity为0则得到一个空数组

             this .elementData = EMPTY_ELEMENTDATA;

         } else {

             throw new IllegalArgumentException( "Illegal Capacity: " +initialCapacity);

         }

     }

public ArrayList() {

     // 使用默认长度大小的数组

   this .elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;

}

public boolean add(E e) {

     // 就此处开始一系列的扩容判断和操作

         ensureCapacityInternal(size + 1 );  // Increments modCount!!

         elementData[size++] = e; // 添加数据

         return true ;

     }

// 下面是add方法中第一行执行的方法  此处minCapacity就是数组的最小容量  也就是当前存储的元素个数+1

private void ensureCapacityInternal( int minCapacity) {

  ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));

     }

private static int calculateCapacity(Object[] elementData, int minCapacity) {

         if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {

             return Math.max(DEFAULT_CAPACITY, minCapacity);

         }

         return minCapacity;

     }

private void ensureExplicitCapacity( int minCapacity) {

         modCount++; // modCount++是做什么的？ 我也不知道

         // overflow-conscious code

         if (minCapacity - elementData.length > 0 )

             grow(minCapacity);

     }

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8 ;

@Native public static final int MAX_VALUE = 0x7fffffff ;

private void grow( int minCapacity) {

         // overflow-conscious code

     // 获取原数组容量

         int oldCapacity = elementData.length;

     // 新数组的容量是原数组容量的1.5倍

         int newCapacity = oldCapacity + (oldCapacity >> 1 );

     // 判断新数组容量是否小于最小容量

         if (newCapacity - minCapacity < 0 )

             newCapacity = minCapacity;

     // 判断新容量是否超过了ArrayList允许的最大值

         if (newCapacity - MAX_ARRAY_SIZE > 0 )

             newCapacity = hugeCapacity(minCapacity);

         // minCapacity is usually close to size, so this is a win:

     // 调用copyOf方法将原数据全部复制到新的空数组中

         elementData = Arrays.copyOf(elementData, newCapacity);

     }

// 超出了ArrayList容量执行hugeCapacity

     private static int hugeCapacity( int minCapacity) {

         // 因为Integer溢出则为负数，此处判断是否溢出

         if (minCapacity < 0 ) // overflow

             // 抛出异常  内存溢出

             throw new OutOfMemoryError();

         // 没有溢出则判断最小容量是否大于了ArrayList允许的最大值

         // 大于--> 返回Integer最大值

         // 小于--> 返回ArrayList允许的最大值

         return (minCapacity > MAX_ARRAY_SIZE) ?

             Integer.MAX_VALUE :

             MAX_ARRAY_SIZE;

     }