集合篇：提升集合性能及避坑

1.批量新增和删除

对应的是集合类的addAll和removeAll方法。

批量新增

在向List和Map中新增大量数据时，应当避开使用for循环逐一添加的方式，应当尽量使用addAll和putAll方法，具体演示如下，

@Test
public void testBatchInsert(){
	// 准备拷贝数据
	ArrayList<Integer> list = new ArrayList<>();
	for(int i=0;i<3000000;i++){
		list.add(i);
	}

	// for 循环 + add
	ArrayList<Integer> list2 = new ArrayList<>();
	long start1 = System.currentTimeMillis();
	for(int i=0;i<list.size();i++){
		list2.add(list.get(i));
	}
	System.out.println("单个 for 循环新增 300 w 个，耗时"+System.currentTimeMillis()-start1);
	
	// 批量新增
	ArrayList<Integer> list3 = new ArrayList<>();
	long start2 = System.currentTimeMillis();
	list3.addAll(list);
	System.out.println("批量新增 300 w 个，耗时"+System.currentTimeMillis()-start2);
}

运行结果，单个循环新增的用时是批量新增的百倍，主要原因在于批量新增过程中只会进行一次扩容。减少了不断扩容、复制所浪费的时间。

以addAll方法为例，其源码如下，

public boolean addAll(Collection<? extends E> c) {
    Object[] a = c.toArray();
    int numNew = a.length;
    // 确保容量充足，整个过程只进行一次扩容
    ensureCapacityInternal(size + numNew);
    // 对数组进行拷贝
    System.arraycopy(a, 0, elementData, size, numNew);
    size += numNew;
    return numNew != 0;
}

HashMap的putAll方法也是同理，整个过程只进行一次扩容大大减少了批量新增的耗时。

同时也提示在容器初始化时，最好能初始化容器的大小，这样可以避免在之后的过程中不断的扩容、复制消耗。

批量删除

批量删除时，ArrayList提供了removeAll方法，而HashMap没有提供批量删除方法。

removeAll方法底层调用的是batchRemove方法，该方法源码如下，

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++)
        	// 依据complement的值决定是否移至头部
            if (c.contains(elementData[r]) == complement)
                elementData[w++] = elementData[r];
    } finally {
        // r和size不等，说明在try的代码过程中出现错误
        // r遍历ArrayList，所以应当与size值相等
        if (r != size) {
        	// r之后是未判断过的数据，将其移动至w后面，不会造成数据丢失
            System.arraycopy(elementData, r,
                             elementData, w,
                             size - r);
            w += size - r;
        }
        // w不等于size说明存在需要被删除的数据，这些数据在w位置之后
        if (w != size) {
            for (int i = w; i < size; i++)
                elementData[i] = null;
            modCount += size - w;
            size = w;
            modified = true;
        }
    }
    return modified;
}

complement 参数默认是 false。

参数值	说明
false	c 中不包含的ArrayList中的数据的节点往头移动。（c中是要删除的值）
true	c 中包含的ArrayList中的数据的节点往头移动。

根据要删除数据和原数组大小的比例来决定，如果要删除的数据很多，选择 false 性能更好。

ArrayList在删除数据时，如果使用for循环的形式，每一次删除后都会对更改过的数组进行拷贝，当数组越大，需要删除数据越多时，会引起很大的消耗。所以批量删除时强烈建议使用removeAll方法。

2.集合类避坑

强制实现equals和hashCode方法

当集合类元素是自定义类时，自定义类强制实现equals和hashCode方法。
集合中除了TreeMap和TreeSet通过比较器对元素大小进行比较外，其余集合类在判断索引位置和相等时，都会使用到equals和hashCode方法。

统一使用迭代器的方法对集合进行修改

所有集合类，在使用for循环进行迭代（即使用迭代器进行迭代）时，如果使用集合类的remove方法，而不是迭代器的remove方法会报出ConcurrentModificationException。建议在任意循环删除的场景下都使用迭代器的删除方法。

数组转集合的坑

public void testArrayToList(){
  Integer[] array = new Integer[]{1,2,3,4,5,6};
  List<Integer> list = Arrays.asList(array);

  // 坑1：修改数组的值，会直接影响原 list
  log.info("数组被修改之前，集合第一个元素为：{}",list.get(0));
  array[0] = 10;
  log.info("数组被修改之前，集合第一个元素为：{}",list.get(0));

  // 坑2：使用 add、remove 等操作 list 的方法时，
  // 会报 UnsupportedOperationException 异常
  list.add(7);
}

坑位	说明
坑 1	数组被修改后，会直接影响到新 List 的值。
坑 2	不能对新 List 进行 add、remove 等操作，否则运行时会报 UnsupportedOperationException 错误。

这两个坑的起因如左右两张图所示，

asList方法返回的List不是java.util.ArrayList，而是Arrays中的一个同名静态类没该类直接持有数组的引用，但是没有实现add、remove等方法。

集合转数组的坑

集合转数组使用toArray方法，但是这个方法很危险，

public void testListToArray(){
	List<Integer> list = new ArrayList<Integer>(){{
		add(1);
		add(2);
		add(3);
		add(4);
	}};

	// 演示有参 toArray 方法，数组大小不够时，得到数组为 null 情况
    Integer[] array0 = new Integer[2];
    list.toArray(array0);
    log.info("toArray 数组大小不够，array0 数组[0] 值是{},数组[1] 值是{},",array0[0],array0[1]);
		
    // 演示数组初始化大小正好，正好转化成数组
    Integer[] array1 = new Integer[list.size()];
    list.toArray(array1);
    log.info("toArray 数组大小正好，array1 数组[3] 值是{}",array1[3]);

    // 演示数组初始化大小大于实际所需大小，也可以转化成数组
    Integer[] array2 = new Integer[list.size()+2];
    list.toArray(array2);
    log.info("toArray 数组大小多了，array2 数组[3] 值是{}，数组[4] 值是{}",array2[3],array2[4]);
}

输出结果，

数组大小不够，array0 数组[0] 值是null,数组[1] 值是null,
数组大小正好，array1 数组[3] 值是4
数组大小多了，array2 数组[3] 值是4，数组[4] 值是null

如果参数数组大小不够，返回的数组的值均为null。所以申明数组时，大小一定要大于等于list的大小，如果容量不足，返回的将是一个空数组。