浅析Java源码之ArrayList

Posted QH-Jimmy

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了浅析Java源码之ArrayList相关的知识,希望对你有一定的参考价值。

  面试题经常会问到LinkedList与ArrayList的区别,与其背网上的废话,不如直接撸源码!

  文章源码来源于JRE1.8,java.util.ArrayList

  既然是浅析,就主要针对该数据结构的内部实现原理和部分主要方法做解释,至于I/O以及高级特性就暂时略过。

 

变量/常量

  首先来看定义的(静态)变量:

class ArrayList2<E>
    //extends AbstractList<E>
    //implements 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;
}

  这里在一开始定义了6个变量,其中第一个跟序列化相关不用管,其余5个依次解释一下:

DEFAULT_CAPACITY:代表容器ArrayList的初始化默认大小

Object[] EMPTY_ELEMENTDATA:一个空数组,在某些方法调用后(例如removeAll)会用到

Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA:默认空数组,未传参初始化时默认为这个

Object[] elementData:保存着当前ArrayList的内容,该变量被标记为序列化忽略对象

int size:很明显,当前ArrayList大小

  需要注意的是,其中几个被标记为static final变量。

 

构造函数

  看完变量,接下来看构造函数部分,构造函数有3个重载版本,分别阐述如下。

1、无参版本

    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

  如果不传任何参数直接初始化一个ArrayList,会得到上面默认的空数组。 

2、int版本

    public ArrayList(int initialCapacity) {
        // 正常情况会初始化一个指定大小的数组
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        }
        // 传0在实现上与不传是一样的
        else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } 
        // 乱传就抛异常
        else {
            throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
        }
    }

  这基本上最普遍的情况,可以看出内部实现就是普通的数组。

3、Collection版本

    public ArrayList(Collection<? extends E> c) {
        // 将集合转换为数组并赋给本地变量
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // 传空集合相当于空数组
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

  如果初始化传入一个集合,会将此集合作为ArrayList的初值。

  这里存在一个bug,即toArray方法返回的不一定是Object,虽然默认情况下是,但是如果被重写就不一定了。

  详细问题可见另一位的博客:http://blog.csdn.net/gulu_gulu_jp/article/details/51457492

  如果返回不是Object类型,会做向上转型。

 

方法

  接下来看看常用的方法。

 

首先是get/set方法:

    public E get(int index) {
        rangeCheck(index);
        return elementData(index);
    }
    public E set(int index, E element) {
        rangeCheck(index);

        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }

  可以看出十分简单暴力,首先会进行范围检查,然后返回/设置对应index的元素。

  简单看一下rangeCheck:

    private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

  也十分简单,主要是判断所给的索引index是否大于数组的大小size,否则抛出异常。

  获取对应的值时,没有直接用elementData[index],而是用了一个方法elementData(),看着有点混,看一下方法定义:

    E elementData(int index) {
        return (E) elementData[index];
    }

  方法其实只是对取出来的值进行了类型转换,保证了返回类型的准确。

 

接下来是add/remove方法

  这两个方法都有重载版本,但是并不复杂,而且都用的比较多。

  首先看add的一个参数版本,会在尾部插入给定元素。

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

  稍微讲下源码注释的modCount,这个变量来源于java.util.AbstractList,专门用来计算容器被改动的次数,对于我这种菜鸟使用者来说没啥用。

  这里会首先检测下容器的容量,然后在尾部加入元素,并将size加1。

  看看ensureCapacityInternal方法:

    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        ensureExplicitCapacity(minCapacity);
    }

  原来这是一个皮包函数,当数组元素为空时,会进行参数修正,由于容器的默认大小为10,所以不会对10以下的容量进行检测。

  修正后,将10或者比10大的形参传入ensureExplicitCapacity进行检测:

    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

  这看起来也像个皮包方法,不过并不是,如果当前容器大小已经达到上限,会调用grow进行扩容:

    private void grow(int minCapacity) {
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

  其实这里的形参名字我觉得不是特别好,应该叫最小所需容量,即minNeededCapacity。

  这里首先会获取当前容器大小,并进行扩容,这里的扩容是这样算的:

  oldCapacity + (oldCapacity >> 1)

  也就是如果之前为10,那么新容量为10 + Math.floor(10/2) = 15。

  得到新容量后,会与传进来的 所需容量进行对比,如果还不够,那就干脆取所需容量为新容量。

  第二个if是判断扩容后的容量是否大于最大(数组可达)整数,看下MAX_ARRAY_SIZE变量定义就明白了:

    /**
     * The maximum size of array to allocate.
     * Some VMs reserve some header words in an array.
     * Attempts to allocate larger arrays may result in
     * OutOfMemoryError: Requested array size exceeds VM limit
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

  这里的注释有必要看一眼,简单讲就是有些JVM会在数组中加入一些东西,所以实际上数组大小是比理论上小一点的。这个很容易理解的,比如电脑硬盘,容量100G,可用容量其实会打个折扣,一个道理的。

  为了完整,所以也看一下hugeCapacity函数的内部实现:

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

  参数检测挺好玩,内部使用的函数还怕传入负数。

  这里会将所需容量与最大可用安全容量作比较,如果实在没办法,就将容量设置为最大可用容量,至于这里会不会出问题我也不知道。

  回到grow方法,得到新的容量后,会调用Arrays.copyOf方法,这个方法是包内另一个类的方法,内部实现是调用System.arraycopy直接进行内存复制,效率很高,最后返回一个新数组,size为加大后的容量。

  

  接下来看第二个重载的add方法:

    public void add(int index, E element) {
        rangeCheckForAdd(index);
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }

  这里的检测不太一样,多了一步,不过看一眼方法就明白了:

    private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

  由于这个重载方法是插入,所以需要进行数值检测,如果插入索引大于数组大小或者小于0,抛个异常。

  接下来是常规的容量检测。

  下一步的方法就是之前提到的System.arraycopy,该方法会将索引+1后面的元素全部复制到源数组,举个简单的例子:

  如果原数组为[1,2,3,4],假设索引为1,经过这一步,数组会变为[1,2,2,3,4]。

  最后是将对应索引的值赋为给定值,size++。

  可以看出,在数组中间插入一个元素是非常耗时的,会变动索引后面的每一个数组元素。

 

  接下来是remove,这个方法也有2个重载,一个是删除给定索引,一个是删除给定元素:

    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; // clear to let GC do its work
        return oldValue;
    }

  没啥好讲的,忽略检测,一句话概括就是将对应索引-1的所有元素复制到原数组,然后size-1,并将末尾元素置null让GC进行回收,最后返回删除元素。

    public boolean remove(Object o) {
        if (o == null) {
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);
                    return true;
                }
        } else {
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }

  这个是第二个重载,对null进行了特殊处理,这个奇怪的东西只能用==来进行比较。

  总体来讲就是遍历数组,如果找到了匹配元素,进行fastRemove,删除成功返回true,否则返回false。

  这个快速删除也没什么稀奇的:

    private void fastRemove(int index) {
        modCount++;
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work
    }

  跟第一个重载的remove很相似,只是移除了范围检测与返回值的处理,更快一些。

 

  其余的方法大多数是上面的变种,没什么研究的必要了,有兴趣的可以自行阅读源码。



以上是关于浅析Java源码之ArrayList的主要内容,如果未能解决你的问题,请参考以下文章

ArrayList源码浅析

Collections.synchronizedList CopyOnWriteArrayListVector介绍源码浅析与性能对比文末福利

Java集合之ArrayList源码解析

ArrayList源码浅析(jdk1.8)

jdk1.7 ArrayList源码浅析

JDK源码--ArrayList浅析