ArrayList.add() 方法源码解析

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

}