容器（五）：王牌飞行员ArrayList

容器（五）：王牌飞行员ArrayList

标签： Java编程思想

---

王牌飞行员申请出战！ 作为List接口中的主要实现类，ArrayList 总是申请出战。

ArrayList概述

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable

ArrayList 是 Java 集合框架中 List接口 的一个实现类。

可以说 ArrayList 是我们使用最多的 List 集合，它是一个动态数组，所谓动态就是它的大小是可变的。实现了所有可选列表操作，并允许包括 null 在内的所有元素。除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。

每个ArrayList实例都有一个容量，该容量是指用来存储列表元素的数组的大小。默认初始容量为10。随着ArrayList中元素的增加，它的容量也会不断的自动增长。在每次添加新的元素时，ArrayList都会检查是否需要进行扩容操作，扩容操作带来数据向新数组的重新拷贝。

注意，ArrayList实现不是同步的。如果多个线程同时访问一个ArrayList实例，而其中至少一个线程从结构上修改了列表，那么它必须保持外部同步。所以为了保证同步，最好的办法是在创建时完成，以防止意外对列表进行不同步的访问：

List list = Collections.synchronizedList(new ArrayList(...)); 

ArrayList 特点如下：

• 容量不固定，想放多少放多少（当然有最大阈值，但一般达不到）
• 有序的（元素输出顺序与输入顺序一致）
• 元素可以为 null
• 效率高
  
  • size(), isEmpty(), get(), set() iterator(), ListIterator() 方法的时间复杂度都是 O(1)
  • add() 添加操作的时间复杂度平均为 O(n)
  • 其他所有操作的时间复杂度几乎都是 O(n)
• 占用空间更小
  
  • 对比 LinkedList，不用占用额外空间维护链表结构

ArrayList的特点决定了我们经常使用它，下面我们源码入手，去探究其成员变量，成员方法以及内部实现。

---

ArrayList的成员变量

Source Code：

//默认初始容量
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;

通过成员变量，我们了解到，ArrayList的底层实际上是一个数组，默认大小为10，具体是如何扩容的还不得而知，需要我们继续看源码。

transient为java关键字，为变量修饰符，如果用transient声明一个实例变量，这个变量的生命周期仅存于调用者的内存中而不会写到磁盘里持久化。

一个对象只要实现了Serilizable接口，这个对象就可以被序列化，我们可以不必关心具体序列化的过程，只要这个类实现了Serilizable接口，这个类的所有属性和方法都会自动序列化。

然而在实际开发过程中，我们常常会遇到这样的问题：这个类的有些属性需要序列化，而其他属性不需要被序列化，打个比方，如果一个用户有一些敏感信息不希望在网络操作（主要涉及到序列化操作，本地序列化缓存也适用）中被传输，这些信息对应的变量就可以加上transient关键字。换句话说，这个字段的生命周期仅存于调用者的内存中而不会写到磁盘里持久化。

总之，java 的transient关键字为我们提供了便利，你只需要实现Serilizable接口，将不需要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会序列化到指定的目的地中。

这里Object[] elementData，就是我们的ArrayList容器，下面介绍的基本操作都是基于该elementData变量来进行操作的。

---

ArrayList 的构造方法

ArrayList提供了三个构造函数：

• ArrayList()：默认构造函数，提供初始容量为10的空列表。

• ArrayList(int initialCapacity)：构造一个具有指定初始容量的空列表。

• ArrayList(Collection<? extends E> c)：构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。

• 
  Source Code：

//初始为空数组
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_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);
    }
}

//直接创建和指定集合一样内容的 ArrayList
public ArrayList(Collection<? extends E> 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;
    }
}

---

添加元素的方法

add(E e)：将指定的元素添加到此列表的尾部。

Source Code：

public boolean add(E e) {
    //对数组的容量进行调整，参数为所需要的最小的长度
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

Analysis：

该方法是在ArrayList的末尾加上一个指定元素e，然后调整底层数组的大小，然后在数组大小size++的位置添加元素e。

---

add(int index, E element)：将指定的元素插入此列表中的指定位置。

Source Code：

//在指定位置添加一个元素
public void add(int index, E element) {
    //对于指定的位置进行范围检查
    rangeCheckForAdd(index);

    //对数组的容量进行调整
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    //复制elementData数组，从index位置开始到结尾的数组（长度为size - index）
    //然后放到从index + 1位置开始到size+1的位置
    //即相当于从index位置开始向右移动一位
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    //加入元素
    elementData[index] = element;
    size++;
}

Analysis：

在指定位置添加元素的思路是：找到这个位置，然后通过System.arraycopy()方法，复制index以后的元素，再粘到index+1的位置，以此来实现右移。

在这个方法中最根本的方法就是System.arraycopy()方法，该方法的根本目的就是将index位置空出来以供新数据插入，这里需要进行数组数据的右移，效率不高。

但是！很多人说：“因为ArrayList是整体移动，所以如果指定的数据集合需要进行大量插入（中间插入）操作，推荐使用LinkedList”

但自己实践一下就知道，不论是在大量插入、还是遍历寻址，ArrayList都比LinkedList要快地多。元素只要达到上万个以后，LinkedList非常地慢，其原因就是在插入时也要先做寻址去找到需要插入的位置，而ArrayList通过数组下标速度非常快。
LinkedList优于ArrayList的场景特别地少。

---

addAll(Collection<? extends E> c)：按照指定 collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素添加到此列表的尾部。

Source Code：

//在指定位置，添加一个集合
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;
    //通过System.arraycopy()方法右移numMoved位
    if (numMoved > 0)
        System.arraycopy(elementData, index, elementData, index + numNew,
                         numMoved);
    //把新的集合数组 添加到指定位置
    System.arraycopy(a, 0, elementData, index, numNew);
    size += numNew;
    return numNew != 0;
}

Analysis：

与在指定位置添加数组的方法差不多，要注意把集合变为数组。

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：它的根本目的就是进行数组元素的复制。即从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。将源数组src从srcPos位置开始复制到dest数组中，复制长度为length，数据从dest的destPos位置开始粘贴。

---

底层数组大小的调整

在刚才的添加元素的方法中，很重要的一步就是调整底层数组的大小，这也是ArrayList作为“动态数组”的根本特性之一。在调整底层数组容量的大小时涉及到一些方法：

Source Code：

//该方法的主要目的是为了调整容量的大小，至少是参数所提供的大小
public void ensureCapacity(int minCapacity) {
    //如果elementData已经不是默认的数组了，则minExpand设为0，否则就是默认容量
    int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) ? 0 : DEFAULT_CAPACITY;

    //当所需要的容器大小 大于minExpand时，就调用确保大小的方法
    if (minCapacity > minExpand) {
        ensureExplicitCapacity(minCapacity);
    }
}

//该方法的主要目的是为了调整容量的大小，至少是参数所提供的大小
private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        //调用确保大小的方法
        ensureExplicitCapacity(minCapacity);
    }

 //   该方法用来扩容，即如果需要调整，就执行扩容函数
 private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // 溢出意识：如果所需大小的长度比现在数组的长度大，那么就执行grow函数
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

Analysis

这三个方法的作用是调整数组的大小，那么如何调整大小呢？交给grow()方法。

---

扩容方法grow()

Source Code：

//扩容以确保它至少能够容纳最小容量参数指定的元素数。
private void grow(int minCapacity) {
    int oldCapacity = elementData.length;
    // 新的数组的长度是原来容量的1.5倍
    int newCapacity = oldCapacity + (oldCapacity >> 1);

    //如果当前容量还没达到 1.5 倍旧容量，就使用当前容量，省的站那么多地方
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;

    //新的容量超出了最大容量 MAX_ARRAY_SIZE，那么就是最大容量
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        //最大容量可以是 Integer.MAX_VALUE
        newCapacity = hugeCapacity(minCapacity);

    // 通过Arrays.copyOf(U[] original, int newLength)方法，将要复制的数组elementData，长度为newCapacity这样的一个数组，赋给新的elementData
    elementData = Arrays.copyOf(elementData, newCapacity);
}

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

Analysis：

底层数组的扩容方法会将原数组复制到一个容量为1.5倍的新数组里。

---

删除元素

ArrayList提供了remove(int index)、remove(Object o)、removeRange(int fromIndex, int toIndex)、removeAll()四个方法进行元素的删除。

remove(int index)：移除此列表中指定位置上的元素。

Source Code：

//根据位置删除
public E remove(int index) {
    rangeCheck(index);

    //modCount是AbstractList类中的transient关键字修饰的变量，供迭代器使用
    modCount++;
    //这个被删除的元素是要被返回的
    E oldValue = elementData(index);

    //numMoved所要移动的元素的个数
    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;
}

---

remove(Object o)：移除此列表中首次出现的指定元素（如果存在）。

Source Code：

//删除某个元素
public boolean remove(Object o) {
    if (o == null) {    //若传入的参数是null
        //挨个遍历找到目标
        for (int index = 0; index < size; index++)
            //那就找到null的元素删掉
            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;
}

其中内部的快速删除方法：fastRemove()用于移除指定位置的元素，就是把之前重复的代码移到一个方法里，没看出来比其他 remove 哪儿快了，如下：

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; // Let gc do its work
    }

---

removeRange(int fromIndex, int toIndex)：移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素（左闭右开）。

Source Code：

protected void removeRange(int fromIndex, int toIndex) {
        modCount++;
        int numMoved = size - toIndex;
        System.arraycopy(elementData, toIndex, elementData, fromIndex,
                        numMoved);

        // Let gc do its work
        int newSize = size - (toIndex - fromIndex);
        while (size != newSize)
            elementData[--size] = null;
    }

---

removeAll()：是继承自AbstractCollection的方法，ArrayList本身并没有提供实现。

Source Code：

public boolean removeAll(Collection<?> c) {
        boolean modified = false;
        Iterator<?> e = iterator();
        while (e.hasNext()) {
            if (c.contains(e.next())) {
                e.remove();
                modified = true;
            }
        }
        return modified;
    }

---

clear()：清除全部元素。

Source Code：

public void clear() {
    modCount++;

    //将所有元素都替换成null，虽然清空了元素但是位置还是保留的
    for (int i = 0; i < size; i++)
        elementData[i] = null;

    size = 0;
}

---

修改元素

set(int index, E element)：将指定位置的元素修改为指定的元素。

Source Code：

public E set(int index, E element) {
    rangeCheck(index);
    E oldValue = elementData(index);

    //直接对数组进行替换操作
    elementData[index] = element;
    //返回原来的值
    return oldValue;
}

---

查询元素

Source Code：

get(int index)：返回此列表中指定位置的元素。

public E get(int index) {
    rangeCheck(index);
    //直接根据数组下标返回元素，贼快
    return elementData(index);
}

---

浅拷贝ArrayList

public Object clone()：返回此ArrayList实例的浅拷贝。 （元素本身不被复制） ，其实是运用了Arrays.copyOf()方法。

Source Code：

 public Object clone() {
        try {
            ArrayList<?> v = (ArrayList<?>) super.clone();

            //Arrays.copyOf()方法强制是浅拷贝
            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);
        }
    }

---

转换为数组

public Object[] toArray()：以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组。这个方法必须分配一个新的数组, 因此，调用者可以自由地修改返回的数组。

此方法充当数组和集合之间的桥梁。

Source Code：

public Object[] toArray() {
    //代码很简单，就是返回一个对于底层数组的复制的新数组
    return Arrays.copyOf(elementData, size);
}

---

public <T> T[] toArray(T[] a)：
以正确的顺序返回一个包含此列表中所有元素的数组;返回的数组的运行时类型是指定数组的运行时类型。

Source Code：

public <T> T[] toArray(T[] a) {
    //如果只是要把一部分转换成数组
    if (a.length < size)
        // Make a new array of a's runtime type, but my contents:
        return (T[]) Arrays.copyOf(elementData, size, a.getClass());
    //全部元素拷贝到 数组 a
    System.arraycopy(elementData, 0, a, 0, size);
    //空位放null
    if (a.length > size)
        a[size] = null;
    return a;
}

调整ArrayList大小

public void trimToSize()：将此 ArrayList 实例的容量调整为列表的当前大小。可以使用此操作来最小化 ArrayList 实例的存储量，即剪掉多余部分。

Source Code：

 public void trimToSize() {
        modCount++;

        //剪掉多余部分，就是将底层数组的直接复制一下，以此来使用真实的size
        if (size < elementData.length) {
            elementData = (size == 0)
              ? EMPTY_ELEMENTDATA
              : Arrays.copyOf(elementData, size);
        }
    }

ArrayList的迭代器

Itr

Itr()继承Iterator接口，对方法进行了实现：

private class Itr implements Iterator<E> {
        int cursor;       // 游标
        int lastRet = -1; // 上一次迭代到的位置
        int expectedModCount = modCount;

        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];
        }

        //调用本类中的remove方法
        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<? super E> 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();
        }
    }

ListItr

 private class ListItr extends Itr implements ListIterator<E> {

        //构造函数，参数为游标初始位置
        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];
        }

        //调用本类的set方法
        public void set(E e) {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

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

        //调用本类的add方法，并将游标右移
        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();
            }
        }
    }

在《容器（四）：List的大管家AbstractList》中我们介绍了 RandomAccess，里面提到：支持 RandomAccess 的对象，遍历时使用 get 比 迭代器更快。

由于 ArrayList 继承自 RandomAccess， 而且它的迭代器都是基于 ArrayList 的方法和数组直接操作，所以遍历时 get 的效率要 >= 迭代器。

for(int i=0 ; i < list.size(); i++)
      list.get(i);

比用迭代器更快：

for (Iterator i=list.iterator(); i.hasNext(); )
     i.next();

另外，由于 ArrayList 不是同步的，所以在并发访问时，如果在迭代的同时有其他线程修改了 ArrayList, fail-fast 的迭代器 Iterator/ListIterator 会报 ConcurrentModificationException 错。

因此我们在并发环境下需要外部给 ArrayList 加个同步锁，或者直接在初始化时用 Collections.synchronizedList 方法进行包装：

List list = Collections.synchronizedList(new ArrayList(...));

ps：用心学习，喜欢的话请点赞 （在左侧哦）