ArrayList内部发生了什么

ArrayList源码分析

这篇文章用来粗浅分析一下ArrayList内部常用的一些方法底层到底发生了什么？

认识一下内部维护的几个成员

transient Object[] elementData;   //维护了一个Object数组，用于存储放入的元素
private int size;  //实际的元素个数
private static final int DEFAULT_CAPACITY = 10;  //默认开辟10个容量
private static final Object[] EMPTY_ELEMENTDATA = {};  //空数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};  //空数组

new一个ArrayList

无参构造函数：
ArrayList<String> arrlist = new ArrayList<>();
内部源码：
public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }	

分析：
可以看到，new一个不带指定容量的ArrayList，除了在堆内存中开辟空间存放对象，只是将对象内部的elementData这个变量指向一个不变的类成员–空数组。
而且，如果在内存中多new几个无参的ArrayList对象，指向的都是同一个空数组。

有参构造函数：
ArrayList<String> arrlist = new ArrayList<>(7);
内部源码：
public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {  //如果指定容量大于0，创建指定容量的Object[]
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {  //如果指定的初始容量为0则执行这里 new ArrayList<>(0);
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    }
}	

放入一个元素

arrlist.add(new Book(“武林外传”));

内部源码：
public boolean add(E e) {
        modCount++;  
        add(e, elementData, size);  //调用另一个add方法
        return true;
    }	
private void add(E e, Object[] elementData, int s) {
        if (s == elementData.length)  //如果实际元素个数等于了数组长度，则扩容
            elementData = grow();
        elementData[s] = e;  //否则，只是进行简单的在第一个空位放入元素，并size++
        size = s + 1;
    }

扩容：grow方法

private Object[] grow() {//如果实际元素个数等于了数组长度，则调用此方法
        return grow(size + 1);  //size+1表示最小的扩容容量
    }
private Object[] grow(int minCapacity) {
        int oldCapacity = elementData.length;  //旧容量：当前长度
        if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { 
         //这里进行的是扩容，调用了ArraysSupport.newLength方法
            int newCapacity = ArraysSupport.newLength(oldCapacity,
                    minCapacity - oldCapacity, //第二个参数结果：size+1-length=1
                    oldCapacity >> 1     //旧容量的2分之一
            return elementData = Arrays.copyOf(elementData, newCapacity);  //这里进行拷贝，将原有的数组拷贝到一个新的容量的空数组里
        } else {  //这里进行的是第一次放入元素时的扩容，DEFAULT_CAPACITY=10，minCapacity=1，明显这里创建了一个容量为10的数组
            return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];
        }
    }
ArraysSupport.newLength:  该方法进行1.5倍扩容
public static int newLength(int oldLength, int minGrowth, int prefGrowth) {
    int newLength = Math.max(minGrowth, prefGrowth) + oldLength;  
       //Max.max(1,oldCapacity >> 1)+oldCapacity 
       //~ (oldCapacity >> 1)+oldCapacity 
       //~ oldCapacity*1.5
    if (newLength - MAX_ARRAY_LENGTH <= 0) {
        return newLength; 
    }
    return hugeLength(oldLength, minGrowth);
}

其中new一个Person的时候，内部的name变量，指向的是字符串常量池中的字符串，jvm会对带双引号的字符串自动创建在常量池中，无需多次开辟空间，节省内存

所以，如果我们知道ArrayList需要放很多数据，可以在new的时候指定一个较大的长度，不用经常性地去扩容，避免底层多次地拷贝

判断是否存在某个元素

arrlist.contains(new Person("…"));

public boolean contains(Object o) {
        return indexOf(o) >= 0;   //内部调用indexOf方法
    }	

arrlist.indexOf(new Person("…"));

public int indexOf(Object o) {
        return indexOfRange(o, 0, size);  //在0~size位置之中查找
    }
int indexOfRange(Object o, int start, int end) {
        Object[] es = elementData;
        if (o == null) {  //如果传入的是null，则循环查找是否有位置为空
            for (int i = start; i < end; i++) {
                if (es[i] == null) {
                    return i;
                }
            }
        } else {  //如果传入的不为null，则循环，用equals方法比较两个对象的值是否相同，可以看出，ArrayList内的元素，需要正确覆写equals方法
            for (int i = start; i < end; i++) {
                if (o.equals(es[i])) {
                    return i;
                }
            }
        }
       	

remove(int index)

public E remove(int index) {
    Objects.checkIndex(index, size);  //判断索引是否越界
    final Object[] es = elementData;
    @SuppressWarnings("unchecked") E oldValue = (E) es[index];  //记录要删除的元素
    fastRemove(es, index);  //这里调用方法进行删除
    return oldValue;
}
private void fastRemove(Object[] es, int i) {
    modCount++;
    final int newSize;
    if ((newSize = size - 1) > i) //如果要删除的不是最后一个元素，则通过copy数组的方式实现向前移位
        System.arraycopy(es, i + 1, es, i, newSize - i);
    es[size = newSize] = null;  //不管删除的是哪个元素，都需要将原来最后元素所占的位置置为null
}

通过源码我们可以发现，如果删除的是最后一个元素，不会触发copy方法，时间复杂度为O(1)；如果删除第i个元素，则会通过System.arraycopy方法，将(i+1,size-1)的元素，向前移动一个位置，最坏的情况就是删除第一个元素，需要复制(size-1)次，时间复杂度为O(n)