Java基础系列-ArrayList

时间 2019-12-09

标签 java 基础系列 arraylist 栏目 Java 繁體版

原文原文链接

原创文章，转载请标注出处：《Java基础系列-ArrayList》java

1、概述

ArrayList底层使用的是数组。是List的可变数组实现，这里的可变是针对List而言，而不是底层数组。git

数组有自身的特色，不变性，一旦数组被初始化，那么其长度就固定了，不可被改变。这就致使了ArrayList中的一个重要特性：扩容。github

2、源码解析

2.1 声明

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{/*...*/}

能够看到ArrayList类实现了四个接口：编程

List ：支持List接口中提供的方法
RandomAccess：支持快速随机访问
有关RandomAccess可见：Java集合系列-RandomAccess
Cloneable：支持对象克隆功能
有关Cloneable可见：Java基础系列-浅拷贝和深拷贝
Serializable：支持序列化功能
有关Serializable可见：Java基础系列-序列化与反序列化

还继承自AbstractList 抽象类，这个抽象类是List 的抽象实现，实现了一些List中的公共方法。数组

2.2 字段解析

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    // 默认的初始容量
    private static final int DEFAULT_CAPACITY = 10;
    // 共享使用的空实例，这个空实例是没有容量的空实例
    private static final Object[] EMPTY_ELEMENTDATA = {};
    // 共享使用的空实例，这个空实例可被扩容到初始容量（10）
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    // ArrayList中保存元素的缓冲数组，DEFAULTCAPACITY_EMPTY_ELEMENTDATA标识的空数组在第一个添加元素时会被扩容到10个大小。
    transient Object[] elementData; // non-private to simplify nested class access
    // ArrayList集合中包含的元素数量
    private int size;
    // 集合的容量最大值为Integer的最大值-8，这里为何减去8呢？主要是由于一些虚拟机会在数组中保存一些头信息，这些信息是区别于使用者添加的元素以外的存在，若是最大为Integer的最大，当头信息添加以后，再添加元素就有可能会形成内存溢出。
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
}

字段中有几个须要注意的点：安全

EMPTY_ELEMENTDATA和DEFAULTCAPACITY_EMPTY_ELEMENTDATA的区别：前者表示的是一个空数组，后者表示的也是一个空数组，可是不一样在于后者是能够扩容的，当往进添加首个元素的时候就会触发扩容机制，容量会扩容到10个长度。
elementData字段是保存元素的缓冲数组，被transient修饰表示它不会被序列化，这意味着集合对象保存的元素不会被自动序列化，因此后面添加了writeObject和readObject方法，用来序列化和反序列化数组中的元素。app

2.3 构造器解析
ArrayList有三个构造器：

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    // 构建一个初始容量是10的ArrayList
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
    // 根据给定的初始容量initialCapacity构建一个ArrayList
    // 若是initialCapacity>0则直接直接建立容量为initialCapacity的ArrayList
    // 若是initialCapacity=0则直接使用EMPTY_ELEMENTDATA空集合
    // 若是initialCapacity<0，则出错。
    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);
        }
    }
    // 将给定的集合转换为ArrayList
    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;
        }
    }    
}

咱们最常使用的实际上是第一种，可是在咱们实际编程时，若是能够预估到集合的最大容量，那么可使用第二种方式，这样能够减小扩容的时间和内存消耗，一次性到位。dom

2.4 添加

2.4.1 添加指定元素

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
}

ensureCapacityInternal方法主要用于校验当前List的容量是否已经达到极限，若是达到极限须要进行扩容。具体参照2.11中扩容解析。函数

剩下的就是添加新元素的逻辑，简单至极，直接将新元素到添加到底层数组elementData的下一下标位size++便可。ui

2.4.2 添加指定元素到指定位置

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    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++;
    }
}

首先校验给定的添加位置index，index必须小于size的值，并大于等于0。

而后一样校验容量是否达到极限，达到极限须要扩容。

以后执行一个本地方法，System.arraycopy方法用于将指定位置及其后面的全部元素整个经过复制迁移到从index+1开始的位置，即总体后移一位，将index位空出来用于保存新元素。

最后将新元素添加到空出的index位置。

2.4.3 将指定集合中的元素添加到List末尾

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    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;
    }
}

首先将给定的集合转换为数组Object[]。

而后以目标List的size+给定集合转化的数组的容量为总容量进行容量校验，若容量不足，执行扩容操做。

再而后经过本地方法执行数组复制操做将给定集合转换数组的元素复制到目标List的底层数组的尾部。

最后不要忘记将size增长。

2.4.4 将指定集合中的元素添加到List指定位置

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    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;
    }
}

首先校验下标index，index必须小于size，大于等于0。

而后将给定集合转换为数组Object[]，再执行容量校验，扩容操做。

经过本地方法数组复制操做将给定位置开始的全部元素总体后移必定的距离，具体的距离为给定集合转换后数组的容量大小，这样就能空出容量大小的空位来存放给定的集合元素。

最后再次经过本地数组复制方法将给定的集合转换的数组元素总体复制到上一步空出来的位置上。

2.5 修改

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    public E set(int index, E element) {
        rangeCheck(index);

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

修改指定位置的元素为新元素，首先须要校验给定index的值，index必须大于等于0，小于size，而后将新元素保存到index位置，并将旧元素返回。

2.6 获取

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    public E get(int index) {
        rangeCheck(index);

        return elementData(index);
    }
}

获取指定下标位置的元素值，首先须要校验给定的下标index，index必须大于等于0，小于size。

2.7 定位

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    public int indexOf(Object o) {
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }
    public int lastIndexOf(Object o) {
        if (o == null) {
            for (int i = size-1; i >= 0; i--)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = size-1; i >= 0; i--)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }
}

indexOf是经过正序遍历的方式搜索给定的元素的下标，lastIndexOf是经过逆序遍历的方式搜索给定元素的下标，这两个方法找到的下标都是正序或者逆序该元素首次出现的位置下标。若是o为null，那么将会搜索第一个null值元素的下标。

2.8 移除

2.8.1 移除指定下标的元素

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    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;
    }
}

首先校验给定的下标值index,index必须小于size，这里的校验和添加元素的下标校验有点不一样：

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
    private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
}

前者是此处的index校验，后者是添加元素的index校验。

那为什么后者比前者要多一个index<0的校验呢，那是由于在add(int,E)方法中，校验完成后紧接着就是调用本地方法进行数组复制操做，若是index小于0，那么出错位置在C代码中，没法在Java代码中得以体现，因此提早进行校验，保证调用本地C代码以前参数的准确性。前者校验完成以后，紧接着的是Java代码获取指定下标的元素，若是下标小于0，也会出错可是JVM会抛出异常，不会无声无息，因此没有必要校验是否小于0。

index校验完成后，经过本地方法数组复制将index+1及其以后的元素总体复制到index位置。

最后将原来的最后一个位置元素置空。

2.8.2 移除指定元素

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    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
    }    
}

首先经过循环操做找到首个指定的元素，而后将针对找到的元素执行删除操做。

删除操做仍是依靠本地的数组复制操做完成的。

2.8.3 清空元素

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    public void clear() {
        modCount++;

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

        size = 0;
    }
}

至于清空元素，就是经过循环将List中的每一个元素都删除，将整个List置空。

2.8.4 移除当前List中全部(不)包含在给定集合中的元素

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    // 删除当前List中全部包含在给定集合中的元素
    public boolean removeAll(Collection<?> c) {
        Objects.requireNonNull(c);
        return batchRemove(c, false);
    }
    // 删除当前List中全部不包含在给定集合中的元素
    public boolean retainAll(Collection<?> c) {
        Objects.requireNonNull(c);
        return batchRemove(c, true);
    }
    private boolean batchRemove(Collection<?> c, boolean complement) {
        final Object[] elementData = this.elementData;
        int r = 0, w = 0;
        boolean modified = false;
        try {
            for (; r < size; r++)
                if (c.contains(elementData[r]) == complement)
                    elementData[w++] = elementData[r];
        } finally {
            // Preserve behavioral compatibility with AbstractCollection,
            // even if c.contains() throws.
            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;
    }
}

2.9 遍历

ArrayList的遍历方式有不少：

2.9.1 ListIterator

ListIterator是继承自Iterator的，在其基础上添加了反向遍历的功能方法。

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    // 截取从执行下标开始的元素组成迭代器实例，进行遍历
    public ListIterator<E> listIterator(int index) {
        if (index < 0 || index > size)
            throw new IndexOutOfBoundsException("Index: "+index);
        return new ListItr(index);
    }
    // 将集合中全部元素组成迭代器实例，进行遍历
    public ListIterator<E> listIterator() {
        return new ListItr(0);
    }
}

源码中的ListItr是ListIterator的实现类。

2.9.2 Iterator

Iterator拥有正向遍历的功能。

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    public Iterator<E> iterator() {
        return new Itr();
    }
}

源码中的Itr就是Iterator的实现类。

2.9.3 Spliterator

Spliiterator是分割迭代器，详情参见Java集合系列-Spliterator

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    public Spliterator<E> spliterator() {
        return new ArrayListSpliterator<>(this, 0, -1, 0);
    }
}

2.9.4 forEach

forEach方式是java 1.8中新增的方式，接受一个行为做为参数，即接收一个方法引用或者Lambda表达式。

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    // action表明接受的行为，是一个函数式接口类型Consumer，表示消费之意，消费就是将资源处理掉，因此有一个入参，无返回值。
    public void forEach(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        final int expectedModCount = modCount;
        @SuppressWarnings("unchecked")
        final E[] elementData = (E[]) this.elementData;
        final int size = this.size;
        for (int i=0; modCount == expectedModCount && i < size; i++) {
            action.accept(elementData[i]);// 执行函数式接口行为
        }
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }
}

实例：

public class ArrayListTest {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.addAll(Arrays.asList("123","444444","2123"));
        ListIterator<String> listIterator = list.listIterator();// 第一种
        listIterator.forEachRemaining(System.out::println);
        System.out.println("-------------");
        ListIterator<String> listIterator1 = list.listIterator(1);// 第二种
        listIterator1.forEachRemaining(System.out::println);
        System.out.println("-------------");
        Iterator<String> iterator = list.iterator();// 第三种
        iterator.forEachRemaining(System.out::println);
        System.out.println("-------------");
        Spliterator<String> spliterator = list.spliterator();// 第四种
        spliterator.forEachRemaining(System.out::println);
        System.out.println("-------------");
        list.forEach(System.out::println);// 第五种
    }
}

2.10 校验

2.10.1 是否为空

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    public boolean isEmpty() {
        return size == 0;
    }
}

size表示的就是List中包含的元素的个数。

2.10.2 是否包含某元素

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }
}

该校验经过indexOf()方法来实现，若是能找到元素的下标，则存在，不然不存在。

2.11 底层数组扩容

在add和addAll方法中屡次出现的ensureCapacityInternal方法就是通向扩容逻辑的通道。

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    // 确保底层数组的容量足够保存当前的元素或元素集，若是容量不足即进行扩容。
    private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }
    // 处理首次添加元素时的容量扩容操做，被指定为DEFAULTCAPACITY_EMPTY_ELEMENTDATA的空数组在首次添加元素时须要自动扩容到默认容量10
    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }
    // 校验是否须要扩容，只有当给定容量值比当前数组的长度要大时，才须要扩容，
    // 由于通常状况下给定容量即为新添加元素后的容量，当前容量达不到这个值是没有位置保存当前元素的，因此才须要扩容。
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

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

ensureCapacityInternal方法的目的是确保给定的参数指定的容量值。

真正的扩容逻辑位于grow方法中：

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);// 扩容为原容量的1.5倍
        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);
    }
    // 处理超限问题
    // 若是给定的minCapacity为负数（首位为1）则抛出异常错误OutOfMemoryError
    // 若是给定容量大于数组最大容量，则取整数的最大值为容量，不然使用数组的最大容量做为扩容容量
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }
}

首先要根据规则计算一个新容量newCapacity，而后将这个新容量值与给定须要的容量值minCapacity进行比较，若是新容量值大于给定容量值，则用新容量值进行扩容，不然使用给定容量值进行扩容。而后进行超限校验和处理。

最后使用肯定好的容量newCapacity来做为新的底层数组容量来进行扩容操做：建立一个新的数组，并迁移元素。

2.12 排序

Java中排序能够经过两种方式实现：

实现Comparable接口
使用Comparator比较器

具体参见Java基础系列-Comparable和Comparator

这里很明显ArrayList的继承体系中并没有Comparable接口，那么只能经过Comparator来实现，这就涉及到了ArrayList中的sort方法：

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    public void sort(Comparator<? super E> c) {
        final int expectedModCount = modCount;
        Arrays.sort((E[]) elementData, 0, size, c);
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
        modCount++;
    }
}

使用这种方式来排序须要传递一个Comparator比较器做为参数，最简单的方式就是匿名内部类方式，在Java 1.8以后直接使用Lambda来实现。

public class ComparatorTest {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.addAll(Arrays.asList("123","45612","7839"));
        list.sort((o1, o2) -> o1.length()-o2.length());
        list.forEach(System.out::println);
    }
}

执行结果为：

123
7839
45612

2.13 克隆

由于ArrayList实现了Cloneable接口，重写了clone方法，便拥有了对象克隆的功能。

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    public Object clone() {
        try {
            ArrayList<?> v = (ArrayList<?>) super.clone();
            v.elementData = Arrays.copyOf(elementData, size);
            v.modCount = 0;
            return v;
        } catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            throw new InternalError(e);
        }
    }
}

这是一个浅拷贝的实现。

2.14 序列化/反序列化

因为ArrayList中使用transient修饰了elementData，它表明的是底层的元素数组，序列化的主要内容就是它，或者说是它里面的内容，而它又没法被序列化，所以咱们只能经过自定义writeObject方法来手动序列化，定义readObject方法来手动反序列化。

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException{
        // Write out element count, and any hidden stuff
        int expectedModCount = modCount;
        s.defaultWriteObject();

        // Write out size as capacity for behavioural compatibility with clone()
        s.writeInt(size);

        // Write out all elements in the proper order.
        for (int i=0; i<size; i++) {
            s.writeObject(elementData[i]);
        }

        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        elementData = EMPTY_ELEMENTDATA;

        // Read in size, and any hidden stuff
        s.defaultReadObject();

        // Read in capacity
        s.readInt(); // ignored

        if (size > 0) {
            // be like clone(), allocate array based upon size not capacity
            int capacity = calculateCapacity(elementData, size);
            SharedSecrets.getJavaOISAccess().checkArray(s, Object[].class, capacity);
            ensureCapacityInternal(size);

            Object[] a = elementData;
            // Read in all elements in the proper order.
            for (int i=0; i<size; i++) {
                a[i] = s.readObject();
            }
        }
    }    
}

至此，ArrayList的大部份内容都介绍完毕了。

3、总结

最后作一下总结，知识点概括：

ArrayList底层采用数组实现，拥有快速随机访问能力，可是非线程安全的集合。
ArrayList默认容量为10，扩容规则为当要保存的新元素所需的容量不足时触发，基本规则为扩容1.5倍。
若是在遍历的时候发生结构性变化，会触发ConcurrentModificationException异常。
结构性变化包括：添加新元素，删除元素。
ArrayList支持序列化功能，支持克隆（浅拷贝）功能，排序功能等。