Java:ArrayList源码分析

Lesincs
243 阅读5分钟

引言

在List家族中,ArrayList可能是我们日常用得最多的了,熟悉其源码能让我们对其更好的理解和使用。本文的源码基于JDK1.8.

基本结构

首先看下面这张图。其中虚线方框表示接口,实线方框表示类,实线实心箭头表示继承,而虚线空心箭头表示实现某一接口。

看图后可以对ArrayList得出以下结论:

  • 继承自AbstractList。
  • 实现了List接口。
  • 实现了RandomAccess接口，即提供了随机访问功能。
  • 实现了Cloneable接口,即覆盖了函数clone()，能被克隆。
  • 实现了Serializable接口,支持可序列化。

ArrayList属性

transient Object[] elementData; //用来存放元素的Object数组
private int size; //元素的大小

既然叫做ArrayList，顾名思义,内部使用Array来存储数据。果然,我们发现,其内部定义了一个Object数组,用来存储数据，还有一个int型的size属性,用来表示元素的大小。

构造函数

  • 无参数构造函数,将DEFAULTCAPACITY_EMPTY_ELEMENTDATA的值赋给elementData
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
  • 含一个整形参数initialCapacity的构造函数,initialCapacity=0时,将EMPTY_ELEMENTDATA的值赋予给elementData,当initialCapacity>0时,创建长度为initialCapacity的Object数组赋值给elementData,否则,抛出异常。
        private static final Object[] EMPTY_ELEMENTDATA = {};
     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);
            }
        }
  • 带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 {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }
    先调用Collection的toArray()方法,将返回结果赋值给elementData.如果elementData的长度为0， 则将EMPTY_ELEMENTDATA赋值给elementData,如果长度不为0，判断一下elementData的类型,因为这里看注释也说明了Collection的toArray()方法因为Java的某个bug可能不会返回Object[],如果是这样的话调用 Arrays的copyOf方法,返回一个Object[]数组给elementData。

以上就是全部的构造方法。这里有一个疑问就是，这三个构造方法都有一种将一个空数组赋值给elementData的情况,为什么无参的赋值的是DEFAULTCAPACITY_EMPTY_ELEMENTDATA,而其余的赋值的是EMPTY_ELEMENTDATA呢？先保留这个疑问继续往下看。

添加元素

  • 最基本的add(E e)方法

       private static final int DEFAULT_CAPACITY = 10;
   public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

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

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

    我们看到在add(E e)方法的内部调用了ensureCapacityInternal(int minCapacity)方法,并把size+1作为minCapacity传递了进去.而在ensureCapacityInternal(int minCapacity)内部中,先判断ArrayList的初始化方式,如果是无参构造的方式,将扩容的数量minCapacity和DEFAULT_CAPACITY相比较，取其中的最大值在将其传给ensureExplicitCapacity(minCapacity)方法.在ensureExplicitCapacity(minCapacity)方法中,先是将modCount这个变量的值加了一位,源码中对这个变量的解释为该变量表示List结构被修改的次数,然后调用了grow(int minCapacity)，顾名思义,该方法为扩容方法。

     private void grow(int minCapacity) {
    //得到旧的容量
    int oldCapacity = elementData.length;
    //oldCapacity>>1 相当于oldCapacity/2 容量增加1.5倍
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    //此处判断是考虑oldCapacity为0的情况
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    //此处是判断容量超出的情况MAX_ARRAY_SIZE的值为Integer.MAX_VALUE - 8
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // 返回一个包含原数组的扩容长度后的数组
    elementData = Arrays.copyOf(elementData, newCapacity);
}
private static int hugeCapacity(int minCapacity) {
//Integer.MAX_VALUE+1的值为负数,所以这里判断是否小于0
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}

    以上就是整个add(E e)方法。对于上面的疑问,我们也得到了答案。

    • 对于无参构造函数,第一次增加元素的时,直接将数组容量扩容至10,此后扩建规律为1.5倍增。
    • 对于下面两种构造,如果初始化数组长度为0,扩容长度依次为1>3>6>9...

    对比这两种扩容方式,如果遇到数据量比较少的情况,可以考虑new ArrayList(0)的初始化方法,容器容量增长比较缓慢,更省内存。

  • add(int index, E element)方法,在制定位置插入数据。

      public void add(int index, E element) {
        rangeCheckForAdd(index); //确认插入的下标是否合法
        ensureCapacityInternal(size + 1);  // 扩容方法
        //native方法 将index以及后面数据整体后移
        System.arraycopy(elementData, index, elementData, index + 1,size - index);
        //在index处插入数据
        elementData[index] = element;
        //容量+1
        size++;
    }
     private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

  • boolean addAll(Collection<? extends E> c),插入集合。

     public boolean addAll(Collection<? extends E> c) {
        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  // Increments modCount
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
        return numNew != 0;
    }

  • boolean addAll(int index, Collection<? extends E> c),在指定位置插入集合。

    public boolean addAll(int index, Collection<? extends E> c) {
        rangeCheckForAdd(index);

        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  // Increments modCount

        int numMoved = size - index;
        if (numMoved > 0)
            System.arraycopy(elementData, index, elementData, index + numNew,
                             numMoved);

        System.arraycopy(a, 0, elementData, index, numNew);
        size += numNew;
        return numNew != 0;
    }

    这两个方法和上面的大同小异,只是先调用集合的c.toArray(),在调用native方法进行插入。不多赘述,进入下一个版块。

获取元素

  • get()
    public E get(int index) {
        rangeCheck(index);
        return elementData(index);
    }
    使用很简单,这里不再赘述。
  • 调用iterator()或者listIterator()得到迭代器对象访问容器元素.

移除元素

  • remove(int index)，移除某个下标的元素
 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;
    }

移除方法也很简单,是将需要被移除的下标后面的元素整体前移,然后将末尾元素的置为null，让GC回收。

  • remove(Object o)，移除某个具体的元素。
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;
    }
    
     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
    }

可以看到,移除某个具体的元素就是遍历整个数组,根绝元素的equals方法判断是否是同一个元素,如果是，根据移除下标的方法移除即可.

结语

对ArrayList进行了一些基础的分析，不是很详尽,后续估计会补充，先更到这里。

avatar
文章
阅读
粉丝