ArrayList 的源碼分析（擴容機制-JDK-10）

Arraylist的源碼分析（擴容機制-JDK 10）

1. 初始化值

   private static final long serialVersionUID = 8683452581122892189L;
   默認數組的初始化容量
   private static final int DEFAULT_CAPACITY = 10;
   空數組元素
   private static final Object[] EMPTY_ELEMENTDATA = {};
   空數組元素
   private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
   存儲ArrayList元素的數組緩衝區
   transient Object[] elementData; // non-private to simplify nested class access
   元素個數
   private int size;
   每次數據進行修改都會+1---主要是在一些非線程安全的時候，檢測是否出現混亂
   protected transient int modCount = 0;

2. 構造方法
   默認數組的長度爲10

   public ArrayList() {
       this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
   }

   本身定義初始化的容量

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

3. 添加元素

   public boolean add(E e) {
     modCount++;
     將元素和數組長度、數組大小（元素的個數）傳過去
     add(e, elementData, size);
     return true;
   }
   private void add(E e, Object[] elementData, int s) {
       若是元素的個數和數組的長度相等，那麼就須要對數組進行擴容
       if (s == elementData.length)
             elementData = grow();
        若是不是，則將元素添加到最後（元素的最後）
        elementData[s] = e;
        而且元素個數+1
        size = s + 1;
   }

4. 開始擴容—擴容的方法

   private Object[] grow() {
   將可容許的數組的最小容量傳過去（元素個數（size+1）—由於要添加一個元素）
   return grow(size + 1);

   }

   private Object[] grow(int minCapacity) {
   調用複製的方法，在原來元素基礎上增長容量
   return elementData = Arrays.copyOf(elementData,
                                      newCapacity(minCapacity));
   }
   
   private int newCapacity(int minCapacity) {
   // overflow-conscious code
   獲取數組的長度（默認的或是本身定義的）
   int oldCapacity = elementData.length;
   新的容量是原容量的1.5倍
   int newCapacity = oldCapacity + (oldCapacity >> 1);
   新容量比可容許的最小容量小，那麼新的容量就是可容許的最小的容量
   之因此會有這個判斷，是由於咱們能夠本身定義初始容量，而不必定是默認的容量
   if (newCapacity - minCapacity <=  0) {
       if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
           return Math.max(DEFAULT_CAPACITY, minCapacity);
       if (minCapacity < 0) // overflow
           throw new OutOfMemoryError();
       return minCapacity;
   }
   若是新容量大於數值的最大值，傳入huge方法，
   return (newCapacity - MAX_ARRAY_SIZE <= 0)
       ? newCapacity
       : hugeCapacity(minCapacity);

   }
   可容許的最小容量是否越界，若是新容量大於數組默認的最大值，賦給它整型的最大值

   private static int hugeCapacity(int minCapacity) {
       if (minCapacity < 0) // overflow
           throw new OutOfMemoryError();
       return (minCapacity > MAX_ARRAY_SIZE)
          ? Integer.MAX_VALUE
          : MAX_ARRAY_SIZE;

   }