ArrayList底层分析

ArrayList是动态数组，底层为java中的数组。

既然底层为数组，那么

1.数组的类型是什么？

Object[] empty={};

2.arrayList的最大容量是多少和初始化容量是多少？

//需要8byte来存储集合本身信息
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;  //(2^31-1)-8

private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        //1.防止栈溢出和越界
        //2.提前达到最大，减少一次扩容的机会
        //这个时候元素数量达到集合存储的极限，任何一次数组迁徙和复制都可能引发内存溢出
        return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
    }

初始化容量：

     /**
     * 默认初始化容量
     * Default initial capacity.
     */
    private static final int DEFAULT_CAPACITY = 10;

但是，使用ArrayList和HashMap的无参构造器时都是采用延迟加载来完成初始化的。

jdk1.8之前，都是直接默认容量为10；

this.elementData = new Object[initialCapacity];//初始化长度为10

1.8之后，为了优化内存使用采用了延迟加载。

ArrayList在add()的时候初始化数组( 初始化容量为10 )，HashMap在put()的时候初始化数组( 初始化容量为16 )。

private static final Object[] EMPTY_ELEMENTDATA = {};

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};//与EMPTY_ELEMENTDATA区分开来以了解添加第一个元素时扩容多少

//transient修饰的成员变量在被序列化后不能被保存
transient Object[] elementData;//不能private修饰

//有参构造器
public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;//空数组
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

//无参构造器
public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;//默认的空数组
    }

3.如何进行动态扩容的？扩容的时机又是什么？

ArrayList<String> list = new ArrayList<String>();
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        list.add("5");
        list.add("6");
        list.add("7");
        list.add("8");
        list.add("9");
        list.add("10");
        System.out.println(list);

public boolean add(E e) {  //e为存储的元素
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;  //size为存储的元素个数
        return true;
    }

private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { //判断是否使用的无参构造器
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);  //minCapacity：size+1  取较大的一方
        }

        ensureExplicitCapacity(minCapacity);
    }

private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0) //判断是否进行扩容   elementData.length为当前容量
            grow(minCapacity);
    }

//扩容方法
private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);//扩容1.5倍
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

关于int newCapacity = oldCapacity + (oldCapacity >> 1);

//把oldCapacity（二进制）右移一位 == oldCapacity（十进制）* 1.5
int newCapacity = oldCapacity + (oldCapacity >> 1); 

//转换为二进制
int a=10；
System.out.println(Integer.toBinaryString(a));//打印结果：1010

4.remove()

int[] array={1，2，3，4，5，6，7，8，9};

//移除下标为6的元素。或者remove("7")
remove(6);

//array:{1，2，3，4，5，6，8，9，null};

被删除元素后的所有元素往前移动，最后的元素被赋null，最后被GC回收。所以数组查询快，增删慢