ArrayList源码浅析

public class ArrayList<E> extends AbstractList<E>
implements List<E>,RandomAccess,Cloneable,java.io.Serializable { private static final long serialVersionUID = 8683452581122892189L; //默认的一个初始化数组大小
    private static final int DEFAULT_CAPACITY = 10; //这两个都是空数组，主要是用来初始化容器或者判断某些给的形参数组是否为空
    private static final Object[] EMPTY_ELEMENTDATA = {}; private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; //实际存放对象的数组
    transient Object[] elementData; //当前的数组中存放的对象的个数
    private int size; //我们平时最常用的无参构造方法
    public ArrayList() { this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; } //比较少用的有参构造方法，直接将给的形参容器复制到我们的arraylist中
    public ArrayList(Collection<? extends E> c) { //将容器转化为数组
        elementData = c.toArray(); //容器是否不是空的，给size(也就是当前的arraylist中对象的个数)中赋值。
        if ((size = elementData.length) != 0) { //判断字节码对象是否相等，也就是类型是否一致，字节码对象只会在第一次加载这种类时加载字节码，且只加载一次
            if (elementData.getClass() != Object[].class) //将内置的数组赋值为该容器转化的数组
                elementData = Arrays.copyOf(elementData,size,Object[].class); } else { //将内置的数组赋值为空数组
            this.elementData = EMPTY_ELEMENTDATA; } } //我们平时常用的add方法
    public boolean add(E e) { //确保容量足够，因为每次添加一个对象，所以给的参数是size+1 //这个方法调用的是最关键的地方，在这之后会调用一个方法将容器的容量扩容
        ensureCapacityInternal(size + 1);  // Increments modCount!! //上面已经确保了容量足够，且没有异常 //所以直接给当前数组的不是null的那个最末尾的下表的下一个赋值 //注意:size是真正的当前存储的对象的个数 //而elementData这个数组是很有可能有一部分位置是空的，也就是null
        elementData[size++] = e; return true; } //确定容量方法,其内调用了一个确定最小容量和一个确定详细容量两个方法
    private void ensureCapacityInternal(int minCapacity) { ensureExplicitCapacity(calculateCapacity(elementData,minCapacity)); } //这个方法内就是判断下elementData是否是空的，是空的就直接判断这个size+1是否比默认的初始容量10大
    private static int calculateCapacity(Object[] elementData,int minCapacity) { if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { //比较minCapacity是否比10大
            return Math.max(DEFAULT_CAPACITY,minCapacity); } return minCapacity; //总之就是返回一个最小的容量数值
 } //该方法确定当前的容量是否足够，并决定是否增加容量
    private void ensureExplicitCapacity(int minCapacity) { //modCount用来记录修改次数，在迭代器内判断是否出现并发修改异常，这个先不管
        modCount++; //上面也说过了，elementData很可能是有一部分是null //所以还需要判断一下，elementData是否足够大 //一般添加一个元素，elementData.length和size是一样大的 //但是不排除我们会使用addAll(Collection<?> c)方法
        if (minCapacity - elementData.length > 0) //容量不够，增加容量，将calculateCapacity方法确定的最小容量传入
 grow(minCapacity); } //增长容量方法
    private void grow(int minCapacity) { int oldCapacity = elementData.length; //(oldCapacity >> 1)是右移操作，相当于除2 //但是这个是最快的，直接将命令给cpu的，我们平时除2也可以这样，能稍微快点，上过组成原理的同学应该知道 //这里就是得到一个elementData.length的1.5倍的值，准备和minCapacity比较出一个合理的值
        int newCapacity = oldCapacity + (oldCapacity >> 1); //如果这个1.5倍的值大于最小容量，那么我们直接取值最小容量就可以 //没必要用1.5倍的值，数组是固定大小，会浪费内存
        if (newCapacity - minCapacity < 0) newCapacity = minCapacity; //MAX_ARRAY_SIZE的定义为private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8 //MAX_ARRAY_SIZE已经很大，接近int的极限，如果比这个值还要大
        if (newCapacity - MAX_ARRAY_SIZE > 0) //得出一个容量值，这个值会非常大
            newCapacity = hugeCapacity(minCapacity); // minCapacity is usually close to size,so this is a win: //这句英文说这个这最小容量通常接近于我们elementData的实际存储对象个数 //大概他觉得我们最长使用的是add(E e)这样的添加很少的元素对象，不会一次添加大量元素对象 //System.arraycopy(original,copy,Math.min(original.length,newLength)); //这个Arrays.copyOf之后会调用上面这一句代码 //original是elementData,newLength是newCapacity,copy是完成扩容后的数组 //最后会return copy，也就是完成了这一次扩容
        elementData = Arrays.copyOf(elementData,newCapacity); } //比较出一个合适的容量值的方法
    private static int hugeCapacity(int minCapacity) { if (minCapacity < 0) // overflow
            throw new OutOfMemoryError ("Required array size too large"); //这里Integer.MAX_VALUE这个值可能会报错 //因为jvm会有一个默认的内存大小，这个值为21亿的MAX_VALUE可能会超过这个内存 //和数组下标越界异常类似，但是这回是内存不够，可以调整jdk默认内存解决
        return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE; } //知道了add(E e)方法后，其他方法也大相径庭 //     public E remove(int index) { //检查是否超出边界范围，只有一句判断是否判处数组越界异常 //private void rangeCheck(int index) { // if (index >= size) // throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); //}
 rangeCheck(index); //同add方法一样，modCount用来记录修改次数
        modCount++; E oldValue = elementData(index); int numMoved = size - index - 1; if (numMoved > 0) //其实ArrayList的改变大小就是靠System.arraycopy这个本地方法完成的
            System.arraycopy(elementData,index+1,elementData,index,numMoved); //清除数组对那个删除对象的引用，垃圾回收器才会回收那个没有引用标记的对象
        elementData[--size] = null; // clear to let GC do its work

        return oldValue; } }

　　　　　try { int[] a=new int[Integer.MAX_VALUE-2]; System.out.println(a.length); } catch (java.lang.OutOfMemoryError e) { e.printStackTrace(); } try { int[] b=new int[Integer.MAX_VALUE]; System.out.println(b.length); } catch (java.lang.OutOfMemoryError e) { e.printStackTrace(); }

　　　　　ArrayList<Integer> list=new ArrayList<>(); list.add(1); list.add(2); list.add(3); Iterator<Integer> iterator = list.iterator(); while(iterator.hasNext()){ System.out.println(iterator.next()); list.remove(0); }