該方法涉及到的方法被我復制到了一個類中，至於解釋，全在註釋上。初次解析，別噴我!!!

如有不足望評論，隨時補充。

package com.nc.sourceCode;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class SourceCodeTest_02<E> {

public static void main(String[] args) {

    user us=new user();

    System.out.println(us.getA());

    List<String> list1=new ArrayList<String>();
    System.out.println("開始添加");
 

// for (Integer i = 0; i <2100000000; i++) {
// list1.add(i.toString());
// }
System.out.println(list1);
list1.add("我就不信了");

    int a1=2147483647;
    int a2=a1+1000;
    System.out.println(a1+"    "+a2);

    System.out.println("=====Arrays.copyOf()方法測試====");
    String [] str={"7","6","5","4","3","2","1"};
    String[] copyOf = Arrays.copyOf(str, 3);
    for (String string : copyOf) {
        System.out.print(string+"   ");
    }
    System.out.println();
    System.out.println(-6-200);
    System.out.println("======位運算符測試======");
    int a=109;
    System.out.println("運算前："+a);
    System.out.println(a>>1);
    System.out.println(a+(a>>1));
    System.out.println(a+a>>1);
    System.out.println("運算後："+a);
    System.out.println("=======list集合測試=========");
    List<String> list=new ArrayList<String>();
    list.add("我去哦");
    int size2 = list.size();
    System.out.println("list.size()="+size2);
    System.out.println(list);
    System.out.println(list.get(0));
    System.out.println("=====數學測試======");
    int max = Math.max(10, 1);
    System.out.println(max);
    System.out.println(Integer.MAX_VALUE);
}

transient Object[] elementData; 
private int size;
public boolean add(E e) {
    ensureCapacityInternal(size + 1);  //進行數組長度處理
    elementData[size++] = e;//實際添加元素的操作
    return true;
}
private void ensureCapacityInternal(int minCapacity) {//類似中轉站
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

private static final int DEFAULT_CAPACITY = 10;
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//返回一個最大值
private static int calculateCapacity(Object[] elementData, int minCapacity) {//判斷數組是否為空（也就是看下是否是第一次集合中添加數據），初始長度為10，否則則就返回數組的下一位元素的下標，也就是上面的size+1
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);//返回兩個值中的大的那個
    }
    return minCapacity;
}

protected transient int modCount = 0;
private void ensureExplicitCapacity(int minCapacity) {
    modCount++;
    if (minCapacity - elementData.length > 0)//超出object[]長度時
        grow(minCapacity);
}
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;//2147483647-8

private void grow(int c) {//在這個方法中進行長度判斷，如果超出當前數組長度，則擴展長度為當前長度的一半或者擴展長度為1
    int a = elementData.length;//獲取數組長度
    int b = a + (a >> 1);//類似於除以2，如果為單數，則減一後除以2
    if (b - c < 0)
        b = c;
    if (b - MAX_ARRAY_SIZE > 0)//基本不可能發生，誰會閑著沒事往一個list集合裏面放21億多個數據呢
        b = hugeCapacity(c);
    elementData = Arrays.copyOf(elementData, b);//拷貝elementData數組元素從0位到c位至elementData數組
}

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

public static <T> T[] copyOf(T[] original, int newLength) {//實際擴產長度的方法，先創建一個指定長度的數組，然後將原數組拷貝到新的數組中並返回新數組
    return (T[]) copyOf(original, newLength, original.getClass());
}

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
    T[] copy = ((Object)newType == (Object)Object[].class)
        ? (T[]) new Object[newLength]
        : (T[]) Array.newInstance(newType.getComponentType(), newLength);//創建一個指定類型和長度的數組
    System.arraycopy(original, 0, copy, 0,
                     Math.min(original.length, newLength));//將original源數組中從第0位開始到Math位結束的元素拷貝到copy數組中從copy數組的地0位開始拷貝
    return copy;
}
 

}

ArrayList.add() 方法吉林快-三平臺出租源碼解析