1.無參構造方法

    //預設初始長度
    private static final int DEFAULT_CAPACITY = 10;

    //初始空陣列
    private static final Object[] EMPTY_ELEMENTDATA = {};


    //共享空陣列 和 EMPTY_ELEMENTDATA 區分用來檢視擴容多少
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    //list儲存資料的陣列
    transient Object[] elementData;

   
 
//list長度
    private int size;


　　public ArrayList() {
　　　　//無參構造直接將 初始空陣列 賦值給 存值陣列
       this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
　　}

2.有參構造

public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            //設定的長度大於0，就根據輸入的長度建立一個數組給 存值陣列
            this.elementData = new
 
 Object[initialCapacity];
        } else if (initialCapacity == 0) {
           //傳入的長度等於0將 共享空陣列給 存值陣列
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
　　　　　　  //傳入負數丟擲異常
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }    
 

3.add方法

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

 /**
  * minCapacity 當前陣列長度+1
  */
 private void ensureCapacityInternal(int minCapacity) {
       ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
 }

/**
 *elementData 存值陣列
 *minCapacity 當前陣列長度+1
 */
private static int calculateCapacity(Object[] elementData, int minCapacity) {
　　　　//判斷 存值陣列 是 空陣列的話
   　　if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
          //放入初始容量 和 當前陣列長度+1 值進行對比 返回數大的
　　　　　　return Math.max(DEFAULT_CAPACITY, minCapacity);
      }
      //當 存值陣列 不為空的話 返回 當前陣列長度+1的值
      return minCapacity;
}

/**
 *minCapacity 返回的最大長度
 */
private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        //返回的最大長度 減去存值陣列長度 大於0的話 標識需要擴容
        if (minCapacity - elementData.length > 0)
            //呼叫擴容方法
            grow(minCapacity);
    }

/**
 *minCapacity 需要擴容的長度
 */
 private void grow(int minCapacity) {
        // 將當前陣列長度給 oldCapacity
        int oldCapacity = elementData.length;
        //當前將陣列長度轉為二進位制 並向右移動一位 轉為16進位制 加上原來的長度 得到新的長度
 　　　　//例如：第一次擴容的時候長度是 10 十進位制轉為二進位制 1010 向右移動一位是 101 二進位制轉為10進位制 為5 用5加上原來的長度10 等於15
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //新長度 減去 需要擴容的長度 小於0
        if (newCapacity - minCapacity < 0)
            //將需要擴容的長度給新長度
            newCapacity = minCapacity;
　　　　　//判斷新長度是否大於最大長度 最大長度為 int的最大長度-8 int的最大長度為 2正128
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        //將 存值陣列 和 擴容長度放入 複製出一個新的陣列給 存值陣列
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

4.get方法

public E get(int index) {
        rangeCheck(index);
        return elementData(index);
}

//判斷下標是否大於等於陣列長度，是的話丟擲陣列越界
private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

5.set方法

public E set(int index, E element) {
    //判斷下標是否越界
    rangeCheck(index);

    E oldValue = elementData(index);
    //將新的給下標
    elementData[index] = element;
    //返回舊的值 
　　return oldValue;
}

private void rangeCheck(int index) {
    if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
//獲取對應下標的值
E elementData(int index) {
    return (E) elementData[index];
}

6.remove方法

public E remove(int index) {
        //判斷下標是否越界
        rangeCheck(index);

        modCount++;
        //獲取原來下標的值
        E oldValue = elementData(index);

        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work

        return oldValue;
    }

  private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
  }

 E elementData(int index) {
    return (E) elementData[index];
 }