Java集合——ArrayList

1. ArrayList概述

  在平时的开发中，我们经常使用List，而其中最常用的就是ArrayList，ArrayList的底层实现是一个长度可变的数组，因为其使用数组结构，所以根据索引操作ArrayList的方法会非常快，时间复杂度为0(1)，例如：get(int index),set(int index, E element);但是，添加和删除元素相对较慢。
  另外，ArrayList不是同步的，也就是在多线程的情况下，如果使用ArrayList可能存在安全问题。如果需要在多线程下使用ArrayList,可以使用Vector,或者使用Collections工具类List list = Collections.synchronizedList（new ArrayList（...）），将ArrayList转化为线程安全的；还可以使用并发容器CopyOnWriteArrayList。

2. 源码阅读

  ArrayList继承了AbstractList类，实现了List,RandomAccess(支持随机访问)，Cloneable，Serializable接口。

2.1 成员变量

// 初始化时默认容量
private static final int DEFAULT_CAPACITY = 10;

/**
 * Shared empty array instance used for empty instances.
 */
private static final Object[] EMPTY_ELEMENTDATA = {};

/**
 * Shared empty array instance used for default sized empty instances. We
 * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
 * first element is added.
 */
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

/**
 * 实际存储结构
 * 使用transient修饰的变量，不会被序列化
 */
transient Object[] elementData; 

/**
 * ArrayList的元素个数
 */
private int size;
// 最大长度
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

• ArrayList为什么定义两个空数组？
    根据以上代码，ArrayList的主要成员变量包括初始容量的大小，底层数组，元素个数；此外，还有两个空数组对象，为什么定义了两个空数组对象呢？根据源码注释的描述，是为了了解列表何时添加第一个元素。
    而在后边的代码中发现，默认情况下，即不指定ArrayList初始容量的大小，使用的是DEFAULTCAPACITY_EMPTY_ELEMENTDATA对象；而如果指定了初始容量的大小为0，使用的是EMPTY_ELEMENTDATA对象。同时，数组扩容时，会判断当前elementData是否是DEFAULTCAPACITY_EMPTY_ELEMENTDATA对象，如果是会设置为初始容量10。

• ArrayList序列化问题？
    另外一个问题，elementData使用了transient修饰，而我们知道transient修饰的变量是不会被序列化和反序列化的，但是ArrayList的元素又存储在elementData中，那么它是如何序列化和反序列化的呢？

    类通过实现java.io.Serializable接口可以启用其序列化功能。要序列化一个对象，必须与一定的对象输出／输入流联系起来，通过对象输出流将对象状态保存下来，再通过对象输入流将对象状态恢复。
    在序列化和反序列化过程中需要特殊处理的类必须使用下列准确签名来实现特殊方法：
  private void writeObject(java.io.ObjectOutputStream out) throws IOException;
  private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException;

    ArrayList中实现了以上两个方法，因此能够实现对elementData的序列化，那么为什么要这么做呢？因为，如果不使用transient，直接序列化elementData数组，而elementData数组的长度，实际会比元素个数长，这就可能造成序列化或者反序列化之后数组有空值的情况，因此，ArrayList自己实现了writeObject(java.io.ObjectOutputStream out)和readObject(java.io.ObjectInputStream in)方法，保证序列化之后数组长度和元素个数相同。

2.2 构造方法

// 指定初始化容量的的构造方法
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);
    }
}

// 
public ArrayList() {
   this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
// 包含一个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;
   }
}

2.3 主要方法

2.3.1 添加元素

// 在数组元素末尾添加元素
public boolean add(E e) {
	// <1>, 扩容操作
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    // 数组添加元素
    elementData[size++] = e;
    
    return true;
}
// 在指定索引位置添加元素（插入元素）
public void add(int index, E element) {
    // 验证索引位置是否在size返回内。
    rangeCheckForAdd(index);
	
	// 扩容
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    // 将索引后边的元素往后移一位
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    // 指定位置添加元素
    elementData[index] = element;
    size++;
}
// 添加一个集合
public boolean addAll(Collection<? extends E> c) {
    Object[] a = c.toArray();
    int numNew = a.length;
    // 扩容
    ensureCapacityInternal(size + numNew);  // Increments modCount
    // 将添加的数组元素，复制到 elementData 中
    System.arraycopy(a, 0, elementData, size, numNew);
    // 修改元素个数
    size += numNew;
    return numNew != 0;
}
// 在指定索引位置添加集合元素
public boolean addAll(int index, Collection<? extends E> c) {
    // 索引是否在size返回内
    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;
}

  通过以上代码，ArrayList可以添加单个元素，也可以直接添加一个Collection集合元素，同时还能在指定索引位置添加。在指定位置添加元素，涉及到索引位置后的元素后移，使用了System.arrycopy方法，该方法参数具体含义，下边介绍。
  另外，由于数组的长度是一定的，而ArrayList是可以一直添加元素的，因此，在添加元素过程中，都会判断是否需要扩容，而扩容的具体方式使用了Arrays.copyOf(T[] original, int newLength),其底层实际也是使用了System.arraycopy方法。扩容过程，效率会较低，因此，如果知道ArrayList长度的情况下，可以在初始化时直接指定对应的长度，防止扩容降低效率。

• System.arraycopy方法：

/**
* 将一个数组复制到另一个数组
* src 原数组
* srcPos 元素组起始位置
* dest 目标数组
* destPos 目标数组复制的起始位置
* length 复制的长度
*/
public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);

扩容操作，具体实现如下：

// 确定容量
private void ensureCapacityInternal(int minCapacity) {
	// <1> 指定初始化容量
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
	
    ensureExplicitCapacity(minCapacity);
}

private void ensureExplicitCapacity(int minCapacity) {
	   //<2> 修改次数 + 1
	   modCount++;
	
	   // <3>, 判断是否需要扩容
	   if (minCapacity - elementData.length > 0)
	       grow(minCapacity);
}
// 扩容操作
private void grow(int minCapacity) {
       // 数组的原长度
       int oldCapacity = elementData.length;
       // 新容量 = 原容量的1.5倍
       int newCapacity = oldCapacity + (oldCapacity >> 1);
       // <4> 如果新容量(原来的1.5倍)，小于传入的容量，就扩容传入的容量数；
       // 否则，扩容为原来的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);
   }

• <1> 处，主要进行设置初始化容量，如果是DEFAULTCAPACITY_EMPTY_ELEMENTDATA,那么，就设置minCapacity为初始化容量10，并进入扩容操作；否则，minCapacity为元素个数+1。
• <2> 处，modCount++,即修改次数加一，该变量在迭代器的迭代过程中，会用到，即迭代过程中如果该参数发生变化，可能会报错，具体可以查看上一篇Java集合学习记录——Iterator中next()方法中的解释。
• <3> 处，判断扩容条件，当minCapacity - elementData.length > 0时，才扩容，ArrayList初始化容量为0，或者未指定初始化容量时，肯定会进行扩容；另外，如果elementData.length大于0，只有等到数组元素满，也就是size == elementData.length时，才会扩容。
• <4> 处，传入的容量minCapacity，在初始化未指定容量的情况下，会是10，此时肯定是直接扩容为10了；其他情况下需要对比minCapacity(可能是size+1,或者size+num)和原容量的1.5倍的大小，扩容后容量为两者中的较大者。

2.3.2 移除元素

移除指定索引位置的元素：

// 移除指定索引的元素，并返回该元素
public E remove(int index) {
	// 判断索引是否在size返回内
    rangeCheck(index);
	// 修改集合修改次数
    modCount++;
    E oldValue = elementData(index);
	// 将索引后边的元素前移一位
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    // 最后一位设置为null，元素个数-1；
    elementData[--size] = null; // clear to let GC do its work

    return oldValue;
}

  根据以上代码，移除指定索引位置元素，首先验证索引是否合法，即在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;
}

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
}

  根据以上代码，移除指定元素，首先遍历集合，找到该元素所在的索引位置，然后，根据索引移除，和上边的方法重复了。另外，在遍历过程中，因为，ArrayList是允许含有null值的，因此，需要区分是否传入的值是否为null，否则，对null使用equals方法，会抛异常。

移除集合元素：

// 删除集合中公共元素
public boolean removeAll(Collection<?> c) {
    Objects.requireNonNull(c);
    return batchRemove(c, false);
}

// 保留集合中公共元素
public boolean retainAll(Collection<?> c) {
    Objects.requireNonNull(c);
    return batchRemove(c, true);
}

  通过以上的代码，看到删除集合中公共元素和保留集合中公共元素，都使用了同一个方法batchRemove，下边来看其具体实现：

private boolean batchRemove(Collection<?> c, boolean complement) {
    final Object[] elementData = this.elementData;
    // <1> 定义两个变量
    int r = 0, w = 0;
    boolean modified = false;
    try {
        for (; r < size; r++)
            // <2> 根据complement，判断将包含的还是不包含的元素覆盖到数组前边
            if (c.contains(elementData[r]) == complement)
                elementData[w++] = elementData[r];
    } finally {
        // Preserve behavioral compatibility with AbstractCollection,
        // even if c.contains() throws.
        // <3> 如果发生了异常，将r后边的元素，复制到w后边
        if (r != size) {
            System.arraycopy(elementData, r,
                             elementData, w,
                             size - r);
            w += size - r;
        }
        
        // <4> 移除多余的元素。
        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;
}

  根据以上代码，batchRemove方法，通过一个boolean类型的参数complement，来确定是保存公共元素，还是删除公共元素。具体思路：

• <1>处，定义两个变量，具体使用在<2>的循环中
• <2>处，使用<1>处定义的一个变量r，遍历集合；然后，通过与参数对比，如果需要删除相同的元素，就将不同元素放在集合的前边，使用另一个变量w,记录其位置；反之，如果需要保留相同元素，则将相同的元素放在数组前边，具体都是与传入的boolean参数complement比对完成的。
  另外，不使用额外数组，使用多个变量操作数组的方式，在算法题目也非常常见，例如：删除排序数组中的重复元素，也是使用两个变量指向索引位置，其实现和上边的方法类似。
• <3> 处，正常情况下，r是会等于size的，只有在发生异常时，才会满足r != size的条件，在该情况下，需要将r后边的元素保留下来，因此，直接将后边的元素，复制到w索引位置后边。
• <4> 处，移除w索引后边的元素，因为前边的方法，只是将需要保留的元素复制到了数组前边的位置，w后边还有元素，因此需要删除掉。同时，这种情况只有w后边还有元素才需要处理，因此需要在w==size的情况下（即保留原来集合中所有元素时），不需要处理，该方法也会返回false。

删除全部元素：

public void clear() {
    modCount++;

    // clear to let GC do its work
    // 遍历集合，均设置为null
    for (int i = 0; i < size; i++)
        elementData[i] = null;

    size = 0;
}

2.3.2.1 Java8中remove方法

removeIf方法:

public boolean removeIf(Predicate<? super E> filter) {
    Objects.requireNonNull(filter);
    // figure out which elements are to be removed
    // any exception thrown from the filter predicate at this stage
    // will leave the collection unmodified
    int removeCount = 0;
    final BitSet removeSet = new BitSet(size);
    final int expectedModCount = modCount;
    final int size = this.size;
    for (int i=0; modCount == expectedModCount && i < size; i++) {
        @SuppressWarnings("unchecked")
        final E element = (E) elementData[i];
        if (filter.test(element)) {
            removeSet.set(i);
            removeCount++;
        }
    }
    if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
    }

    // shift surviving elements left over the spaces left by removed elements
    final boolean anyToRemove = removeCount > 0;
    if (anyToRemove) {
        final int newSize = size - removeCount;
        for (int i=0, j=0; (i < size) && (j < newSize); i++, j++) {
            i = removeSet.nextClearBit(i);
            elementData[j] = elementData[i];
        }
        for (int k=newSize; k < size; k++) {
            elementData[k] = null;  // Let gc do its work
        }
        this.size = newSize;
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
        modCount++;
    }

    return anyToRemove;
}

  该方法，传入一个lambda表达式，然后，使用了位图，将符合条件的元素索引记录在位图中，然后，再遍历一次集合，保留不需要删除的元素。

replaceAll修改集合中的元素：

public void replaceAll(UnaryOperator<E> operator) {
    Objects.requireNonNull(operator);
    final int expectedModCount = modCount;
    final int size = this.size;
    for (int i=0; modCount == expectedModCount && i < size; i++) {
        elementData[i] = operator.apply((E) elementData[i]);
    }
    if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
    }
    modCount++;
}

  该方法也是传入一个lambda表达式，然后，遍历集合，对每个元素执行传入的lambda函数操作。

2.3.2.2 List循环中移除元素

  关于移除方法，还有一个常见的问题，就是循环中删除元素。我们可以看一下具体实现：
使用for循环：

public static void testRemove() {
	// list中元素为["1","2","2","3"]
   List<String> list = createArrayList();
    for (int i = 0; i < list.size(); i++) {
        if (list.get(i).equals("2")) {
            list.remove(i);
        }
    }
    System.out.println(Arrays.toString(list.toArray()));
}

  根据前边ArrayList中remove方法，删除了元素之后，后边的元素会向移动一位，但是，在循环中又执行了i++操作，因此，如果有连续两个元素相同的元素与要删除的元素相同，会漏掉后边的元素，例如上边的例子，输出结果为：

[1, 2, 3]

使用forearch循环：

public static void testRemove1() {
    List<String> list = createArrayList();
    for (String item : list) {
        if (item.equals("2")) {
            list.remove(item);
        }
    }
    System.out.println(Arrays.toString(list.toArray()));
}

  直接修改for循环中的方法，使用forEarch循环，java中forearch循环,实际是使用了迭代器，而在Java集合学习记录——Iterator中，知道了迭代器迭代过程中，会判断修改次数是否和期望修改次数相同，而上边的remove方法，会修改集合的修改次数。因此，输出结果为：

Exception in thread "main" java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)
	at java.util.ArrayList$Itr.next(ArrayList.java:851)
	at collections.iterator.Test.testRemove1(Test.java:20)
	at collections.iterator.Test.main(Test.java:15)

正确的方法1——使用iterator中的remove方法：

public static void testRemove2() {
    List<String> list = createArrayList();
    Iterator<String> iterator = list.iterator();
    while (iterator.hasNext()) {
        if (iterator.next().equals("2")) {
            iterator.remove();
        }
    }
    System.out.println(Arrays.toString(list.toArray()));
}

  正确的做法是，使用迭代器遍历集合，然后，使用迭代器中的删除方法，因为在上一篇关于iterator的文章中，我们知道iterator的remove方法，虽然，也会修改modCount，但是，会再次设置expectedModeCount的值，具体也可以再ArrayList的子类Itr的remove方法中查看。
方法2——使用Java8新增方法removeIf：

public static void testRemove3() {
    List<String> list = createArrayList();
    list.removeIf(s -> {
        return s.equals("2");
    });
    System.out.println(Arrays.toString(list.toArray()));
}

2.3.3 查询方法

获取指定索引位置的元素：

// 获取指定索引的元素
public E get(int index) {
	// 验证索引位置是否合法，
    rangeCheck(index);
	// 返回数组该索引位置的元素
    return elementData(index);
}

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

判断某个元素是否存在：

public boolean contains(Object o) {
    return indexOf(o) >= 0;
}
// 获取元素第一次出现的位置
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;
}

判断集合是否为空，以及获取元素个数

public boolean isEmpty() {
   return size == 0;
}

public int size() {
    return size;
}

2.3.3 修改元素

  修改元素的方法，除了上边replaceAll方法外，Java8之前，提供了set(int index, E element)方法，修改指定索引位置的元素：

// 修改指定索引的元素，并返回旧值
public E set(int index, E element) {
    rangeCheck(index);

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

总结：

  ArrayList其底层实现是一个数组，因此具备数组的特性，针对索引的相关操作会相对较快，例如get(int index),set(int index, E element)等；但是，由于数组的长度是一定的，因此，添加元素可能会涉及到数组的扩容操作，会相对较慢；另外，插入和删除元素涉及到元素的移动，也会相对较慢。在使用List时，如果添加，插入等操作比较频繁，建议使用LinkedList;如果使用ArrayList时，知道元素的个数，可以直接初始化时设置其容量，避免因为扩容导致效率降低。