ArrayList源码解析

1 /**
2      * elementData:Object[] elementData
3      * Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}
4      * 将elementData初始化为一个空数组
5      */
6     public ArrayList() {
7         this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
8     }

 1 //eg1:e=100 size=0
 2     //eg2:e=200 size=1
 3     //eg3:e=1100 size=10 测试扩容
 4     public boolean add(E e) {
 5         //eg3:此步骤已经将elementData.length由10扩容为15
 6         ensureCapacityInternal(size + 1);  // Increments modCount!!
 7         //eg1:elementData[0]=100,size=1
 8         //eg2:elementData[1]=200,size=2
 9         //eg3:elementData[10]=1100,size=11
10         elementData[size++] = e;
11         return true;
12     }

//eg1:minCapacity=1
    //eg2:minCapacity=2
    //eg3:minCapacity=11
    private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

/**
     * 判断elementData是否为空数组,minCapacity=elementData.size+1
     * @param elementData
     * @param minCapacity
     * @return
     */
    //eg1:elementData={},minCapacity=1
    //eg2:elementData={100},minCapacity=2
    //eg2:elementData={100,200,...,1000},minCapacity=11
    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        //eg1:true
        //eg2:false
        //eg3:false
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            //eg1:DEFAULT_CAPACITY=10 return 10
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
        }

/**
     * 自增对象的操作次数,判断是否需要扩容
     * @param minCapacity
     */
    //eg1:minCapacity=10
    //eg2:minCapacity=2
    //eg3:minCapacity=11
    private void ensureExplicitCapacity(int minCapacity) {
        //记录对对象的操作次数
        modCount++;
        // overflow-conscious code
        //eg1:minCapacity=10,elementData.length=0 true
        //eg2:minCapacity=2,elementData.length=10 false
        //eg2:minCapacity=11,elementData.length=10 true
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

 1 /**
 2      * 扩容操作,
 3      */
 4     /**
 5      * 位运算
 6      * 4>>1,右移一位,相当于(int)value/2
 7      * 0100>>1=0010=2
 8      * 4<<1左移一位,相当于value*2
 9      * 0100<<1=1000=8
10      */
11     //扩容操作
12     //eg1:minCapacity=10
13     //eg3:minCapacity=11
14     private void grow(int minCapacity) {
15         // overflow-conscious code
16         //eg1:oldCapacity=0
17         //eg3:oldCapacity=10
18         int oldCapacity = elementData.length;
19         //eg1:newCapacity=0
20         //eg3:newCapacity=10+5=15
21         int newCapacity = oldCapacity + (oldCapacity >> 1);
22         //eg1:true,newCapacity=10
23         //eg3:false,newCapacity=15
24         if (newCapacity - minCapacity < 0)
25             newCapacity = minCapacity;
26         //eg1:MAX_ARRAY_SIZE=Integer.MAX_VALUE - 8,false
27         //eg3:false
28         if (newCapacity - MAX_ARRAY_SIZE > 0)
29             newCapacity = hugeCapacity(minCapacity);
30         // minCapacity is usually close to size, so this is a win:
31         //eg1:elementData=new Object[10]
32         //eg3:elementData.length=15
33         elementData = Arrays.copyOf(elementData, newCapacity);
34     }

 1 //eg1:index=2,size=11,elementData={100,200,300,...,1100}
 2     public E remove(int index) {
 3         //判断index是否越界
 4         //eg1:index=2
 5         rangeCheck(index);
 6 
 7         modCount++;
 8         //eg1:oldValue=elementData[2]=300
 9         E oldValue = elementData(index);
10         //eg1:numMoved=11-2-1=8
11         int numMoved = size - index - 1;
12         //eg1:numMoved=8,true
13         if (numMoved > 0)
14         /**
15          * System.arraycopy,将src数组下标为3后续的8个value复制到desc数组下标为2开始的8个value
16          * eg1:System.arraycopy(
17          *         {100,200,300,...,1100}, //src数组
18          *         3,//src数组下标
19          *         {100,200,300,...,1100},//desc数组
20          *         2,//desc下标
21          *         8//移动的位数
22          * )
23          */
24             System.arraycopy(elementData, index+1, elementData, index,
25                              numMoved);
26         //eg1:elementData={100,200,400,500,600,700,800,900,1000,1100,1100}
27         elementData[--size] = null; // clear to let GC do its work
28         //eg1:elementData={100,200,400,500,600,700,800,900,1000,1100}
29         return oldValue;
30     }