细说JDK1.8下的ArrayList

最近在准备秋招,打算把自己看的Javase源码通过博客的方式记录下来,以便后面翻看

首先要说的是ArrayList, ArrayList作为开发中最常用到的集合类,在面试中也是经常会被问到它的底层实现,所以就让我们一起来揭开它的神秘面纱吧。

一 什么是ArrayList

public class ArrayList extends AbstractList
        implements List, RandomAccess, Cloneable, java.io.Serializable

从上面ArrayList的继承实现关系中,可以看到ArrayList实现了List,而我们知道List接口实现了Collection接口,所以 ArrayList也是一种用来存放对象的容器。同时还能看到ArrayList实现了Cloneable和Serialiable接口,证明它是可以被克隆和序列化的

二 ArrayList的成员变量

 private static final long serialVersionUID = 8683452581122892189L;

    /**
     * 数组默认初始化容量为10
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * 空数组,当制定该ArrayList容量为0时,返回该数组
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

    /**
     *默认空数组,这是jdk1.8之后新加入的,它与上面数组的区别是:该数组是默认返回的,
     *而上面是用户指定容量为0时返回的
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    /**
     * 存放元素的数组,被transient修饰
     */
    transient Object[] elementData; // non-private to simplify nested class access

    /**
     * ArrayList当前元素的个数
     */
    private int size;

说明:从上面ArrayList的成员变量我们可以看出ArrayList底层是通过维护了一个数组来存放元素的,该数组的默认初始化容量为10,那么有人会说,那直接通过数组来存放元素就行了,实际上,ArrayList不同于数组,它是可以动态孔扩容的。还有一点,细心的同学可能会发现ArrayList底层维护的数组是被transient所修饰的,证明该数组是不可以被序列化的,而上面又说到ArrayList实现了Serialiable接口,岂不是反序列化后的ArrayList丢失了原先的元素?其实玄机在于ArrayList中的两个方法:writeObject和readObject,  ArrayList在序列化的时候会调用writeObject,直接将size和element写入ObjectOutputStream;反序列化时调用readObject,从ObjectInputStream获取size和element,再恢复到elementData。
       为什么不直接用elementData来序列化,而采用上诉的方式来实现序列化呢?原因在于elementData是一个缓存数组,它通常会预留一些容量,等容量不足时再扩充容量,那么有些空间可能就没有实际存储元素,采用上诉的方式来实现序列化时,就可以保证只序列化实际存储的那些元素,而不是整个数组,从而节省空间和时间。这里就不贴上他们的源码了,有兴趣可以自己去看一下。

三 ArrayList的构造器

ArrayList有三个构造器,如下代码:

    /**
     *制定初始化容量的构造器
     */
    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);
        }
    }

    /**
     * 没有入参的构造器,可以看到数组是上文的DEFAULTCAPACITY_EMPTY_ELEMENTDATA成员变量
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    /**
     * 入参为集合的构造器
     */
    public ArrayList(Collection c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray 可能返回的不是一个Object数组
            if (elementData.getClass() != Object[].class)
                //使用 Arrays.copy 方法拷创建一个 Object 数组
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

四  ArrayList的增删改查

接下来就是ArrayList的重头戏了,首先让我们来看添加方法:

    /**
     * 添加一个元素
     */
    public boolean add(E e) {
        //对数组容量进行调整
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

    /**
     * 在制定位置添加一个元素
     */
    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++;
    }
    //添加一个集合
    public boolean addAll(Collection c) {
        //把该集合转为对象数组
        Object[] a = c.toArray();
        int numNew = a.length;
        //增加容量
        ensureCapacityInternal(size + numNew);  // Increments modCount
        //挨个向后迁移
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
        //新数组有元素,就返回 true
        return numNew != 0;
    }

    //在指定位置,添加一个集合
    public boolean addAll(int index, Collection 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;
    }

可以看到,所有的添加方法都调用了ensureCapacityInternal()进行数组容量的调整,下面就让我们一起来看看这个方法:

//minCapacity为size+新添加的元素个数,即最小容量
private void ensureCapacityInternal(int minCapacity) {
        //调用了ensureExplicitCapacity和calculateCapacity两个方法
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

private static int calculateCapacity(Object[] elementData, int minCapacity) {
        //如果数组等于默认的空数组,则通过比较默认容量10和minCapacity的大小,返回那个大的
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }   
        //否则直接返回minCapacity
        return minCapacity;
    }
private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // 容量不够,调用grow方法进行扩容
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
 private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        //新容量为老容量的1.5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //如果新容量小于最小容量,则将最小容量赋值给新容量
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        //如果新容量大于阈值
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            //最大容量可以是 Integer.MAX_VALUE
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity 一般跟元素个数 size 很接近,所以新建的数组容量为 newCapacity 更宽松些
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

说明:上面添加的代码有点多,有些人看起来可能会觉得很烦躁,所以i我简单的总结一下,首先我们ArrayList有四个添加元素的方法,当我们添加新的元素时,ArrayList底层的数组容量可能会不够,这时我们需要调用ensureCapacityInternal(int minCapacity)方法对数组的容量进行判断,如果不够就调用grow(int minCapacity)方法对数组进行扩容,新容量默认为老容量的1.5倍,如果老容量的1.5倍依然不够,则将最小容量作为新容量。

看完ArrayList的添加方法,修改和查询相对就容易多了,都是根据角标进行操作,直接上代码:

  public E set(int index, E element) {
        //检查角标是否越界
        rangeCheck(index);

        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }
   public E get(int index) {
        //检查角标是否越界
        rangeCheck(index);

        return elementData(index);
    }

接着看删除方法: 

//根据角标删除一个元素    
public E remove(int index) {
        //查看是否角标越界
        rangeCheck(index);

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

        int numMoved = size - index - 1;
        if (numMoved > 0)
            //调用arraycopy将角标后的元素整体前移
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        //将size最后一位清空,gc防止内存泄漏
        elementData[--size] = null; // clear to let GC do its work
        //将删除的元素返回
        return oldValue;
    }
//删除指定的一个元素,通过遍历数组进行删除
 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
    }
 public boolean removeAll(Collection c) {
        Objects.requireNonNull(c);
        return batchRemove(c, false);
    }
   //删除或者保留指定集合中的元素
private boolean batchRemove(Collection c, boolean complement) {
    final Object[] elementData = this.elementData;
    //使用两个变量,一个负责向后扫描,一个从 0 开始,等待覆盖操作
    int r = 0, w = 0;
    boolean modified = false;
    try {
        //遍历 ArrayList 集合
        for (; r < size; r++)
            //如果指定集合中是否有这个元素,根据 complement 判断是否往前覆盖删除
            if (c.contains(elementData[r]) == complement)
                elementData[w++] = elementData[r];
    } finally {
        //发生了异常,直接把 r 后面的复制到 w 后面
        if (r != size) {
            System.arraycopy(elementData, r,
                             elementData, w,
                             size - r);
            w += size - r;
        }
        if (w != size) {
            // 清除多余的元素,clear to let GC do its work
            for (int i = w; i < size; i++)
                elementData[i] = null;
            modCount += size - w;
            size = w;
            modified = true;
        }
    }
    return modified;
}

    //清除整个ArrayList
    public void clear() {
        modCount++;

        // clear to let GC do its work
        for (int i = 0; i < size; i++)
            elementData[i] = null;

        size = 0;
    }

说明:看完删除方法都知道,删除完一个元素后还要进行数组的前移,所以删除的效率会比较慢,这也是我们如果经常用到添加修改的时候会用LinkedList而不用ArrayList的原因。

五  ArrayList的内部类

ArrayList中有两个内部类,分别是Itr和ListItr,他们都实现了Iterator接口,相信Iterator大家都不会陌生,迭代器嘛,通过游标来遍历集合的,具体没什么好讲的,看看代码就可以了:

private class Itr implements Iterator {
        int cursor;       // index of next element to return
        int lastRet = -1; // index of last element returned; -1 if no such
        int expectedModCount = modCount;

        Itr() {}

        public boolean hasNext() {
            return cursor != size;
        }

        @SuppressWarnings("unchecked")
        public E next() {
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }

        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

        @Override
        @SuppressWarnings("unchecked")
        public void forEachRemaining(Consumer consumer) {
            Objects.requireNonNull(consumer);
            final int size = ArrayList.this.size;
            int i = cursor;
            if (i >= size) {
                return;
            }
            final Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length) {
                throw new ConcurrentModificationException();
            }
            while (i != size && modCount == expectedModCount) {
                consumer.accept((E) elementData[i++]);
            }
            // update once at end of iteration to reduce heap write traffic
            cursor = i;
            lastRet = i - 1;
            checkForComodification();
        }

        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

    /**
     * An optimized version of AbstractList.ListItr
     */
    private class ListItr extends Itr implements ListIterator {
        ListItr(int index) {
            super();
            cursor = index;
        }

        public boolean hasPrevious() {
            return cursor != 0;
        }

        public int nextIndex() {
            return cursor;
        }

        public int previousIndex() {
            return cursor - 1;
        }

        @SuppressWarnings("unchecked")
        public E previous() {
            checkForComodification();
            int i = cursor - 1;
            if (i < 0)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i;
            return (E) elementData[lastRet = i];
        }

        public void set(E e) {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                ArrayList.this.set(lastRet, e);
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

        public void add(E e) {
            checkForComodification();

            try {
                int i = cursor;
                ArrayList.this.add(i, e);
                cursor = i + 1;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }
    }

可以看到在Itr和ListItr中的方法中都有一个 checkForComodification()的方法 ,因为ArrayList不是线程安全的,当我们通过Iterator遍历ArrayList时,可能有其他线程正在对ArrayList进行操作,这时候就会通过 checkForComodification()触发fail-fast机制。

六  总结

好的,看到这里,ArrayList就讲的差不多了,其实它还有一些方法我没有贴上来,因为这篇博客已经很长了,可能很多小伙伴都看睡着了,所以到最后我来总结一下。ArrayList底层是一个可以动态扩容的数组,初始化容量为10,每次扩容为原来的1.5倍(如果1.5倍不够,就使用最小容量作为新容量),ArrayList的特点是修改查询快,删除添加慢,刚好和LinkedList相反。

 

你可能感兴趣的:(javase基础)