第七周总结

ArrayList的构造方法：

无参构造：通过无参构造生成一个空的数组，这个数组在赋第一个值后它的容量会被自动扩展到10
有参构造：<1>通过给定一个值作为容量，创建之后这个值就是这个数组的初始容量。

<2>通过给一个集合并且把这个集合的元素作为数组的元素来创建一个数组

ArrayList的常用方法(增、删、改、查)

import java.util.ArrayList;
public class Test3 {
    public static void main(String[] args) {
        ArrayList arr1 = new ArrayList();
        ArrayList arr2 = new ArrayList(20);
        //增加元素
        for(int i=0;i<10;i++) {
            arr1.add(i);//这个方法直接是直接把输入的那个元素增加到数组的最后面
        }
        arr1.add(3,4);//这个方法是把元素4下标为3的位置去,3后面的元素全都往后移一个
                                    //还有addAll方法来把集合中的元素全部加到这个数组里来
        System.out.println(arr1.toString());//输出[0, 1, 2, 4, 3, 4, 5, 6, 7, 8, 9]
        arr1.add(2,'j');
        System.out.println(arr1.toString());//[0, 1, j, 2, 4, 3, 4, 5, 6, 7, 8, 9]
        //删除元素
        arr1.remove(3);//删除指定下标处的元素
        System.out.println(arr1.toString());//[0, 1, j, 4, 3, 4, 5, 6, 7, 8, 9]
        //查找
        System.out.println(arr1.contains(3));//查看某个特定的元素在不在这个数组里面，在就返回true
        System.out.println(arr1.get(5));//返回指定下标处的元素
        }
}

ArrayList扩容

ArrayList创建的数组的容量是可以动态变化的，使用各种add方法来增加一个元素的时候都会先调用ensrueCapacityInternal方法，通过传入需要的最小容量来看是不是需要扩大容量。

ensrueCapacityInternal方法

private void ensureCapacityInternal(int minCapacity) {
       ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

calculateCapacity方法

private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {//判断数组是不是空的
            return Math.max(DEFAULT_CAPACITY, minCapacity);//如果是空的就将传入的所需要最小
            //容量与，默认的DEFAULT_CAPACITY来进行比较取较大值，DEFULT_CAPACITY的值是10，一个空
            //的数组赋第一个值得时候，传入的minCapacity等于0，就取DEFULT_CAPACITY，所以说一个空
            //的数组赋第一个值就容量就变成了10，个人理解这个方法的存在就是为数组是空的时候服务的
        }
        return minCapacity;
}

ensureExplicitCapacity方法

private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)//当所需要的最小容量大于现有容量的时候就需
            //要扩大容量，不然放不下
            grow(minCapacity);
    }

grow方法

    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);//oldCapacity >> 1,相当于是
        //把oldCapacity除以2，也就是说每次调用grow方法容量就会变成差不多原来的1.5倍
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;//如果新的容量小于所需要的最小容量就把所需要的最小容量最
        //为新的容量
        if (newCapacity - MAX_ARRAY_SIZE > 0)//如果新的容量比数组最大的容量还大的话就调用
            //hugeCapacity方法把所需要的最小容量和MAX_ARRAY_SIZE进行比较，要是MAX_ARRAY_SIZE
            //比所需最小容量小的话就取Integer.MAX_VALUE,否则就取MAX_ARRAY_SIZE
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

hugeCapacity方法

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