【Java集合类】ArrayList详解 (JDK7)

相信对于使用过Java的人来说，ArrayList这个类大家一定不会陌生。

数据结构课上讲过，

 

 

Array是数组，它能根据下标直接找到相应的地址，所以索引速度很快，但是唯一的缺点是不能动态改变数组的长度，复杂度O(1)。

而List就是链表，它搜索相应地址都只能从链表头部一个一个找下去，直至找到对应的地址才停止，相比于数组来说，搜索速度肯定是慢的，但是有点是能动态的增删节点，复杂度O(n)。

 

 

而Java中这个ArrayList到底是什么东西呢？

先上代码，我们平时使用ArrayList一般这样使用:

public class ArrayListTest {

    public static void main( String[] args ) {
        List<Integer> list = new ArrayList<Integer>();
        list.add( 1 );
        list.add( 2 );
        list.get( 0 );
        list.remove( 0 );
    }
}

好，现在来解释每一步操作jdk做的事:

先看new ArrayList<>()初始化，

    public ArrayList(int initialCapacity) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];
    }

    /**
     * Constructs an empty list with an initial capacity of ten.
     */
    public ArrayList() {
        this(10);
    }

很明显，如果初始化不指定capacity的话，默认初始化数组大小就是10。

其实细心发现，在重载的构造函数中，

this.elementData = new Object[initialCapacity];

这行代码暴露了ArrayList的本质，其实就是一个数组。

OK，现在我们拥有了一个长度为10的数组对象，现在我们执行add操作，看jdk操作

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

1.首先，暂且不理会ensureCapacityInternal()方法做的事，直接看【elementData[size++]=e】这行代码，显然地，是在elementData对象的size索引位置指向新元素，问题来了，万一size已经超出了当前数组的最大长度（假设是在第11个位置放置新元素），怎么办？

这里就要看ensureCapacityInternal方法了。

    private void ensureCapacityInternal(int minCapacity) {
        modCount++;
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

这里可以很清楚地看出，

minCapacity - elementData.length > 0

这行代码检查了新增的元素位置是否超出了当前数组对象的最大长度，基于上面的假设，此判断是成立的，所以需要继续往下看，看grow()方法。

    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        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);
    }

看第二行代码，newCapacity = oldCapacity + oldCapacity / 2;
就是说每次当发现当前数组长度不足时，每次增加的步长是【0.5倍的当前长度】。
Ps.注意这里有一个坑，假如增加长度后超出了Max_ARRAY_SIZE(jdk定义为maxIntValue-8)，直接返回MaxIntValue。

最后就是调用Arrays.copyOf方法了，里面主要调用的是System.arrayCopy方法，是一个JNI调用，有兴趣的同学可以去JDk官网看底层的实现，这里就不多累赘了。


--------------------------------------------------------------------------------------------------------------------------------

--------------------------------------------------------------------------------------------------------------------------------

接着来看看remove方法。

    public E remove(int index) {
        rangeCheck(index);

        modCount++;
        E oldValue = elementData(index);

        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // Let gc do its work

        return oldValue;
    }

 

remove就比较简单了，它的原理就是找到要删除的下标，假设数组[1,2,3,4,5]你要删除3，jdk的做法就是把[1,2]和[4,5]数组复制到原数组，形成新数组[1,2,4,5,5]，
然后执行elementData[--Size]防止内存泄露，完毕~

总结:
ArrayList就是一个通过申请新内存来扩容的数组！