List<String> list=new ArrayList<String>();
      解析原始碼的方法>>>  list.add("hello");

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

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

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

}