这篇文章我根据《阿里巴巴Java开发手册》总结了关于集合使用常见的注意事项以及其具体原理。
强烈建议小伙伴们多多阅读几遍，避免自己写代码的时候出现这些低级的问题。
集合判空
《阿里巴巴Java开发手册》的描述如下：
判断所有集合内部的元素是否为空，使用isEmpty()方法，而不是size()==0的方法。
这是因为isEmpty()方法的可读性更好，并且时间复杂度为O(1).
绝大部分我们使用的集合的size()方法的时间复杂度也是O(1),不过，也有很多复杂度不是O(1)的，比如java.util.concurrent包下的某些集合（ConcurrentLinkedQueue,ConcurrentHashMap...）
下面是ConcurrentHashMap的size()方法和isEmpty（）方法的源码
public int size() {
long n = sumCount();
return ((n < 0L) ? 0 :
(n < (long)Integer.MAX_VAlUE) ? Integer.MAX_VALUE :
(int)n);
}
final long sumCount() {
CounterCell[] as = counterCells;CounterCell a;
long sum = baseCount;
if (as != null) {
for (int i = 0;i < as.length;++i){
if ((a = as[i]) != null)
sum += a.value;
}
}
reuturn sum;
}
public boolean isEmpty() {
return sumCount() <=0L;//ignore transient negative values
}
集合转Map
《阿里巴巴Java开发手册》的描述如下：
在使用java.util.stream.Collectors类的toMap（）方法转为Map集合时，一定要注意当value为null时会抛NPE异常
class Person{
private String name;
private String phoneNumber;
// getter and setter
}
List
bookList.add(new Person("jack","18163138123");
boolList.add(new Person("martin",null));
// 空指针异常
bookLisy.stream().collect(Collectiors.toMap(Person::getName,Person::getPhoneNumber));
下面我们来解释一下原因。
首先，我们来看java.util.stream.Collections类的toMap()方法，可以看到其内部调用了Map接口的merge()方法。
public static
Collector
Function valueMapper,
BinaryOperator mergeFunction,
Supplier
BiConsumer
valueMapper.apply(element),mergeFunction);
return new CollectiorImpl<>(mapSupplier,accumulator,mapMerger(mergeFunvtion),CH_ID);
Map接口的merge()方法如下，这个方法是接口中默认实现。
如果你还不了解Java8新特性的话，请看这篇文章：《Java8新特性总结》
default V merge(K key, V value,
BiFunction remappingFunction) {
Objects.requireNonNull(remappingFunction);
Objects.requireNonNull(value);
V oldValue = get(key);
V newValue = (oldValue == null) ? value :
remappingFunction.apply(oldValue,value);
if(newValue == null) {
remove(key);
} else {
put(key,newValue);
}
return newValue
merge()方法会先调用Objects.requireNonNull()方法判断value是否为空
public static
if (obj == null)
throw new NullPointerException();
return obj;
}
集合遍历
《阿里巴巴Java开发手册》的描述如下：
不要在foreach循环里进行元素的remove/add操作。
remove元素请使用Iterator方式，如果并发操作，需要对Iterator对象加锁。
通过反编译你会发现foreach语法底层其实还是依赖Iterator.
不过，remove/add操作直接调用的是集合自己的方法，而不是Iterator的remove/add方法
这就是导致Iterator莫名其妙地发现自己有元素被remove/add，然后，它就会抛出一个ConcurrentModificationException来提示用户发生了并修改异常。
这就是单线程状态下产生的fail-fast机制。
fail-fast机制：多个线程对fail-fast集合进行修改的时候，可能会抛出ConcurrentModificationException.
即使是单线程下也有可能会出现这种情况，上面已经提到过。
相关阅读：什么是fail-fast
Java8开始，可以使用Collection#removeIf（）方法删除满足特定条件的元素，如
List
for (int i = 1; i <= 10; ++i) {
list.add(i);
}
list.removeIf(filter -> filter % 2 == 0);/* 删除list中的所有偶数 */
System.out.println(list)/*[1,3,5,7,9]*/
除了上面介绍的直接使用Iterator进行遍历操作之外，你还可以：
使用普通的for循环
使用fail-safe的集合类。
java.util包下面的所有的集合类都是fail-fast的，而java.utik.concurrent包下面的所有的类都是fail-safe的
.........
集合去重
《阿里巴巴Java开发手册》的描述如下：
可以利用Set元素唯一的特性，可以快速对一个集合进行去重操作，避免使用List的contains()进行遍历去重或者判断包含操作
这里我们以HashSet和ArrayList为例说明
// Set 去重代码示例
public static
if (Collections.isEmpty(data)) {
return new HashSet<>();
}
return new HashSet<>(data);
}
//List 去重代码示例
public static
if (CollectionUtilrs.isEmpty(data)) {
return new ArrayList<>();
}
List
for (T current : data) {
if (!result.contains(current)) {
result.add(current);
}
}
return result;
}
两者的核心差别在于contains()方法的实现
HashSet的contains()方法底部依赖的HashMap的containKey()方法，时间复杂度接近于O(1)(没有出现哈希冲突的时候O(1)).
private transient HashMap
public boolean contains(Object o)
return map.containsKey(o);
}
我们有N个元素插入进Set中，那时间复杂度就接近是O(n)
ArrayList的contains()方法是通过遍历所有元素的方法来做的，时间复杂度接近是O(n)
public boolean contains(Object o) {
return indexOf(o) >= 0;
}
public int indexOf(Object o) {
if (o == null) {
for (int i = o; i < size; i++)
if (elementData[i]==null)
return i;
} else {
for (int i = 0; i if (o.equals(elementData[i])) return i; } return -1; } 集合转数组 《阿里巴巴Java开发手册》的描述如下： 使用集合转数组的方式，必须使用集合toArray(T[] array),传入的是类型完全一致，长度为0的空数组。 toArray(T[] array)方法的参数是一个泛型数组没，如果toArray方法中没有传递任何参数的话返回的是Object类型数组。 String[] s=new String[]{ "dog","lazy","a","over","jumps","fox","brown","quick","A" }; List Collections.reverse(list); //没有指定类型的话会报错 s=list.toArray(new String[0]); 由于JVM优化，new String[0]作为Collection.toArray()方法的参数现在使用更好，new String[0]就是起一个模版的作用，指定了返回数组的类型，o是为了节省空间，因为它只是为了说明返回的类型。 详见：https://shiplev.net/blog/2016/arrays-wisdow-ancients/ 数组转集合 《阿里巴巴Java开发手册》的描述如下： 使用工具类Arrays.asList()把数组转换成集合时，不能使用其修改集合相关的方法，它的add/remove/clear方法会抛出UnsupportedOperationException异常 我在之前的一个项目中就遇到一个类似的坑。 Arrays.asList()在平时开发中还是比较常见的，我们可以使用它将一个数组转换为一个List集合。 String[] myArray = {"Apple","Banana","Orange"}; List //上面两个语句等价于下面一条语句 List JDK源码对于这个方法的说明： /** *返回由指定数组支持的固定大小的列表。 *此方法作为基于数组和基于集合的API之间的桥梁 *与Collection.toArray()结合使用。 *返回的List是可序列化并实现RandomAccess接口 */ public static return new ArrayList<>(a); } 下面我们来总结一下使用注意事项。 1.Arrays.asList()是泛型方法，传递的数组必须是对象数组，而不是基本类型。 int[] myArray = {1,2,3}; List myList = Arrays.asList(myArray); System.out.println(myList.size());//1 System.out.println(myList.get(0));//数组地址值 System.out.println(myList.get(1));//报错：ArrayIndexOutOfBoundsException int[] array = (int[]) myList.get(0); System.out.println(array[0);//1 当传入一个原生数据类型数组时，Arrays.asList()的真正得到的参数就不是数组中的元素，而是数组对象本身！ 此时List的唯一元素就是这个数组，也就解释了上面的代码 我们使用包装类型数组就可以解决这个问题 Integer[] myArray = {1,2,3}; 2.使用集合的修改方法：add(),remove(),clear()会抛出异常 List myList = Arrays.asList(1,2,3); myList.add(4);//运行时报错：UnsupportedOperationException myList.remove(1);//运行时报错：UnsupportedOperationException myList.clear();//运行时报错：UnsupportedOperationException Arrays.asList()方法返回的并不是java.util.ArrayList，而是java.util.Arrays的一个内部类，这个内部类并没有实现集合的修改方法或者说并没有重写这些方法。 List myList = Arrays.asList(1,2,3); System.out.println(myList.getClass());//class java.util.Arrays$ArrayList 下图是java.util.Arrays$ArrayList的简易源码，我们可以看到这个类型重写的方法有那些 private static class ArrayList { ... @Override public E get(int index) { ... } @Override public W set(int index,E element) { ... } @Override public int indexOf(Object o) { ... } @Override public boolean contains(Object o) { ... } @Override public void forEach(Consumer action) { ... } @Override public void replaceAll(UnaryOperator .... } @Override public void sort(Comparator c) { .... } } 我们再看一下java.util.AbstractList的add/remove/clear方法就知道为什么会抛出UnsuportedOperationException了。 public E remove(int index) { throw new UnsupportedOperationException(); } public boolean add(E e) { add(size(),e); return true; } public void add(int index,E element) { throw new UnsupportedOperationException(); } public void clear() { removeRange(0,size()); } protected void removeRange(int fromIndex,int toIndex) { ListIterator for (int i=0,n=toIndex-fromIndex; i it.next(); it.remove(); } } 那我们如何正确的将数组转换为ArrayList? 1.手动实现工具类 //JDK1.5+ static final List for (final T s array) { 1.add(s); } return l; } Integer [] myArray = { 1, 2, 3 }; System.out.println(arrayToList(myArray).getClass());//class java.util.ArrayList 2.最简便的方法 List list = new ArrayList<>(Arrays.asList("a","b","c")) 3.使用Java8的Stream（推荐） Integer [] myArray = { 1,2,3 }; List myList = Arrays.stream(myArray).collect(Collectors.toList()); //基本类型也可以实现转换（依赖boxed的装箱操作） int [] myArray2 = { 1,2,3 }; List myList = Arrays.stream(myArray2).boxed().collect(Collectors.toList()); 4.使用Guava 对于不可变集合，你可以使用ImmutableList类及其of()与copyOf()工厂方法:(参数不能为空） List List 对于可变集合，你可以使用Lists类及其newArrayList()工厂方法： 5.使用Apache CommonsCollections List CollectionUtils.addAll(list,str); 6.使用Java9的List.of（）方法 Integer[] array = {1,2,3}; List