服务器之家:专注于服务器技术及软件下载分享
分类导航

PHP教程|ASP.NET教程|Java教程|ASP教程|编程技术|正则表达式|C/C++|IOS|C#|Swift|Android|VB|R语言|JavaScript|易语言|vb.net|

服务器之家 - 编程语言 - Java教程 - Java 集合使用不当,Code Review 被 Diss了!

Java 集合使用不当,Code Review 被 Diss了!

2021-08-26 23:34JavaGuideGuide哥 Java教程

有很多小伙伴在写代码的时候,有一些比较基础的问题没有考虑到,导致项目 Code Review 的时候被 diss。

Java 集合使用不当,Code Review 被 Diss了!

大家好,我是 Guide!

有很多小伙伴在写代码的时候,有一些比较基础的问题没有考虑到,导致项目 Code Review 的时候被 diss。

上周五 Code Review 的时候,团队有个工作1年多的小伙伴使用 Java 集合的时候就出现了一个非常基础的问题。

这篇文章我根据《阿里巴巴 Java 开发手册》总结了关于集合使用常见的注意事项以及其具体原理。

强烈建议小伙伴们多多阅读几遍,避免自己写代码的时候出现这些低级的问题。

集合判空

《阿里巴巴 Java 开发手册》的描述如下:

判断所有集合内部的元素是否为空,使用 isEmpty() 方法,而不是 size()==0 的方式。

这是因为 isEmpty() 方法的可读性更好,并且时间复杂度为 O(1)。

绝大部分我们使用的集合的 size() 方法的时间复杂度也是 O(1),不过,也有很多复杂度不是 O(1) 的,比如 java.util.concurrent 包下的某些集合(ConcurrentLinkedQueue 、ConcurrentHashMap...)。

下面是 ConcurrentHashMap 的 size() 方法和 isEmpty() 方法的源码。

  1. public int size() { 
  2.     long n = sumCount(); 
  3.     return ((n < 0L) ? 0 : 
  4.             (n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE : 
  5.             (int)n); 
  6. final long sumCount() { 
  7.     CounterCell[] as = counterCells; CounterCell a; 
  8.     long sum = baseCount; 
  9.     if (as != null) { 
  10.         for (int i = 0; i < as.length; ++i) { 
  11.             if ((a = as[i]) != null
  12.                 sum += a.value; 
  13.         } 
  14.     } 
  15.     return sum
  16. public boolean isEmpty() { 
  17.     return sumCount() <= 0L; // ignore transient negative values 

集合转 Map

《阿里巴巴 Java 开发手册》的描述如下:

在使用 java.util.stream.Collectors 类的 toMap() 方法转为 Map 集合时,一定要注意当 value 为 null 时会抛 NPE 异常。

  1. class Person { 
  2.     private String name
  3.     private String phoneNumber; 
  4.      // getters and setters 
  5.  
  6. List<Person> bookList = new ArrayList<>(); 
  7. bookList.add(new Person("jack","18163138123")); 
  8. bookList.add(new Person("martin",null)); 
  9. // 空指针异常 
  10. bookList.stream().collect(Collectors.toMap(Person::getName, Person::getPhoneNumber)); 

下面我们来解释一下原因。

首先,我们来看 java.util.stream.Collectors 类的 toMap() 方法 ,可以看到其内部调用了 Map 接口的 merge() 方法。

  1. public static <T, K, U, M extends Map<K, U>> 
  2. Collector<T, ?, M> toMap(Function<? super T, ? extends K> keyMapper, 
  3.                             Function<? super T, ? extends U> valueMapper, 
  4.                             BinaryOperator<U> mergeFunction, 
  5.                             Supplier<M> mapSupplier) { 
  6.     BiConsumer<M, T> accumulator 
  7.             = (map, element) -> map.merge(keyMapper.apply(element), 
  8.                                           valueMapper.apply(element), mergeFunction); 
  9.     return new CollectorImpl<>(mapSupplier, accumulator, mapMerger(mergeFunction), CH_ID); 

Map 接口的 merge() 方法如下,这个方法是接口中的默认实现。

如果你还不了解 Java 8 新特性的话,请看这篇文章:《Java8 新特性总结》 。

  1. default V merge(K key, V value, 
  2.         BiFunction<? super V, ? super V, ? extends V> remappingFunction) { 
  3.     Objects.requireNonNull(remappingFunction); 
  4.     Objects.requireNonNull(value); 
  5.     V oldValue = get(key); 
  6.     V newValue = (oldValue == null) ? value : 
  7.                remappingFunction.apply(oldValue, value); 
  8.     if(newValue == null) { 
  9.         remove(key); 
  10.     } else { 
  11.         put(key, newValue); 
  12.     } 
  13.     return newValue; 

merge() 方法会先调用 Objects.requireNonNull() 方法判断 value 是否为空。

  1. public static <T> T requireNonNull(T obj) { 
  2.     if (obj == null
  3.         throw new NullPointerException(); 
  4.     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。即使是单线程下也有可能会出现这种情况,上面已经提到过。

Java8 开始,可以使用 Collection#removeIf()方法删除满足特定条件的元素,如

  1. List<Integer> list = new ArrayList<>(); 
  2. for (int i = 1; i <= 10; ++i) { 
  3.     list.add(i); 
  4. list.removeIf(filter -> filter % 2 == 0); /* 删除list中的所有偶数 */ 
  5. System.out.println(list); /* [1, 3, 5, 7, 9] */ 

除了上面介绍的直接使用 Iterator 进行遍历操作之外,你还可以:

  • 使用普通的 for 循环
  • 使用 fail-safe 的集合类。java.util包下面的所有的集合类都是 fail-fast 的,而java.util.concurrent包下面的所有的类都是 fail-safe 的。
  • ......

集合去重

《阿里巴巴 Java 开发手册》的描述如下:

可以利用 Set 元素唯一的特性,可以快速对一个集合进行去重操作,避免使用 List 的 contains() 进行遍历去重或者判断包含操作。

这里我们以 HashSet 和 ArrayList 为例说明。

  1. // Set 去重代码示例 
  2. public static <T> Set<T> removeDuplicateBySet(List<T> data) { 
  3.  
  4.     if (CollectionUtils.isEmpty(data)) { 
  5.         return new HashSet<>(); 
  6.     } 
  7.     return new HashSet<>(data); 
  8.  
  9. // List 去重代码示例 
  10. public static <T> List<T> removeDuplicateByList(List<T> data) { 
  11.  
  12.     if (CollectionUtils.isEmpty(data)) { 
  13.         return new ArrayList<>(); 
  14.  
  15.     } 
  16.     List<T> result = new ArrayList<>(data.size()); 
  17.     for (T current : data) { 
  18.         if (!result.contains(current)) { 
  19.             result.add(current); 
  20.         } 
  21.     } 
  22.     return result; 

两者的核心差别在于 contains() 方法的实现。

HashSet 的 contains() 方法底部依赖的 HashMap 的 containsKey() 方法,时间复杂度接近于 O(1)(没有出现哈希冲突的时候为 O(1))。

  1. private transient HashMap<E,Object> map; 
  2. public boolean contains(Object o) { 
  3.     return map.containsKey(o); 

我们有 N 个元素插入进 Set 中,那时间复杂度就接近是 O (n)。

ArrayList 的 contains() 方法是通过遍历所有元素的方法来做的,时间复杂度接近是 O(n)。

  1. public boolean contains(Object o) { 
  2.     return indexOf(o) >= 0; 
  3. public int indexOf(Object o) { 
  4.     if (o == null) { 
  5.         for (int i = 0; i < size; i++) 
  6.             if (elementData[i]==null
  7.                 return i; 
  8.     } else { 
  9.         for (int i = 0; i < size; i++) 
  10.             if (o.equals(elementData[i])) 
  11.                 return i; 
  12.     } 
  13.     return -1; 

我们的 List 有 N 个元素,那时间复杂度就接近是 O (n^2)。

集合转数组

《阿里巴巴 Java 开发手册》的描述如下:

使用集合转数组的方法,必须使用集合的 toArray(T[] array),传入的是类型完全一致、长度为 0 的空数组。

toArray(T[] array) 方法的参数是一个泛型数组,如果 toArray 方法中没有传递任何参数的话返回的是 Object类 型数组。

  1. String [] s= new String[]{ 
  2.     "dog""lazy""a""over""jumps""fox""brown""quick""A" 
  3. }; 
  4. List<String> list = Arrays.asList(s); 
  5. Collections.reverse(list); 
  6. //没有指定类型的话会报错 
  7. s=list.toArray(new String[0]); 

由于 JVM 优化,new String[0]作为Collection.toArray()方法的参数现在使用更好,new String[0]就是起一个模板的作用,指定了返回数组的类型,0 是为了节省空间,因为它只是为了说明返回的类型。详见:https://shipilev.net/blog/2016/arrays-wisdom-ancients/

数组转集合

《阿里巴巴 Java 开发手册》的描述如下:

使用工具类 Arrays.asList() 把数组转换成集合时,不能使用其修改集合相关的方法, 它的 add/remove/clear 方法会抛出 UnsupportedOperationException 异常。

我在之前的一个项目中就遇到一个类似的坑。

Arrays.asList()在平时开发中还是比较常见的,我们可以使用它将一个数组转换为一个 List 集合。

  1. String[] myArray = {"Apple""Banana""Orange"}; 
  2. List<String> myList = Arrays.asList(myArray); 
  3. //上面两个语句等价于下面一条语句 
  4. List<String> myList = Arrays.asList("Apple","Banana""Orange"); 

JDK 源码对于这个方法的说明:

  1. /** 
  2.   *返回由指定数组支持的固定大小的列表。此方法作为基于数组和基于集合的API之间的桥梁, 
  3.   * 与 Collection.toArray()结合使用。返回的List是可序列化并实现RandomAccess接口。 
  4.   */ 
  5. public static <T> List<T> asList(T... a) { 
  6.     return new ArrayList<>(a); 

下面我们来总结一下使用注意事项。

1、Arrays.asList()是泛型方法,传递的数组必须是对象数组,而不是基本类型。

  1. int[] myArray = {1, 2, 3}; 
  2. List myList = Arrays.asList(myArray); 
  3. System.out.println(myList.size());//1 
  4. System.out.println(myList.get(0));//数组地址值 
  5. System.out.println(myList.get(1));//报错:ArrayIndexOutOfBoundsException 
  6. int[] array = (int[]) myList.get(0); 
  7. System.out.println(array[0]);//1 

当传入一个原生数据类型数组时,Arrays.asList() 的真正得到的参数就不是数组中的元素,而是数组对象本身!此时 List 的唯一元素就是这个数组,这也就解释了上面的代码。

我们使用包装类型数组就可以解决这个问题。

  1. Integer[] myArray = {1, 2, 3}; 

2、使用集合的修改方法: add()、remove()、clear()会抛出异常。

  1. List myList = Arrays.asList(1, 2, 3); 
  2. myList.add(4);//运行时报错:UnsupportedOperationException 
  3. myList.remove(1);//运行时报错:UnsupportedOperationException 
  4. myList.clear();//运行时报错:UnsupportedOperationException 

Arrays.asList() 方法返回的并不是 java.util.ArrayList ,而是 java.util.Arrays 的一个内部类,这个内部类并没有实现集合的修改方法或者说并没有重写这些方法。

  1. List myList = Arrays.asList(1, 2, 3); 
  2. System.out.println(myList.getClass());//class java.util.Arrays$ArrayList 

下图是 java.util.Arrays$ArrayList 的简易源码,我们可以看到这个类重写的方法有哪些。

  1. private static class ArrayList<E> extends AbstractList<E> 
  2.       implements RandomAccess, java.io.Serializable 
  3.   { 
  4.       ... 
  5.  
  6.       @Override 
  7.       public E get(int index) { 
  8.         ... 
  9.       } 
  10.  
  11.       @Override 
  12.       public E set(int index, E element) { 
  13.         ... 
  14.       } 
  15.  
  16.       @Override 
  17.       public int indexOf(Object o) { 
  18.         ... 
  19.       } 
  20.  
  21.       @Override 
  22.       public boolean contains(Object o) { 
  23.          ... 
  24.       } 
  25.  
  26.       @Override 
  27.       public void forEach(Consumer<? super E> action) { 
  28.         ... 
  29.       } 
  30.  
  31.       @Override 
  32.       public void replaceAll(UnaryOperator<E> operator) { 
  33.         ... 
  34.       } 
  35.  
  36.       @Override 
  37.       public void sort(Comparator<? super E> c) { 
  38.         ... 
  39.       } 
  40.   } 

我们再看一下java.util.AbstractList的 add/remove/clear 方法就知道为什么会抛出 UnsupportedOperationException 了。

  1. public E remove(int index) { 
  2.     throw new UnsupportedOperationException(); 
  3. public boolean add(E e) { 
  4.     add(size(), e); 
  5.     return true
  6. public void add(int index, E element) { 
  7.     throw new UnsupportedOperationException(); 
  8.  
  9. public void clear() { 
  10.     removeRange(0, size()); 
  11. protected void removeRange(int fromIndex, int toIndex) { 
  12.     ListIterator<E> it = listIterator(fromIndex); 
  13.     for (int i=0, n=toIndex-fromIndex; i<n; i++) { 
  14.         it.next(); 
  15.         it.remove(); 
  16.     } 

那我们如何正确的将数组转换为 ArrayList ?

1、手动实现工具类

  1. static <T> List<T> arrayToList(final T[] array) { 
  2.   final List<T> l = new ArrayList<T>(array.length); 
  3.  
  4.   for (final T s : array) { 
  5.     l.add(s); 
  6.   } 
  7.   return l; 
  8.  
  9.  
  10. Integer [] myArray = { 1, 2, 3 }; 
  11. System.out.println(arrayToList(myArray).getClass());//class java.util.ArrayList 

2、最简便的方法

  1. List list = new ArrayList<>(Arrays.asList("a""b""c")) 

3、使用 Java8 的 Stream(推荐)

  1. Integer [] myArray = { 1, 2, 3 }; 
  2. List myList = Arrays.stream(myArray).collect(Collectors.toList()); 
  3. //基本类型也可以实现转换(依赖boxed的装箱操作) 
  4. int [] myArray2 = { 1, 2, 3 }; 
  5. List myList = Arrays.stream(myArray2).boxed().collect(Collectors.toList()); 

4、使用 Guava

对于不可变集合,你可以使用ImmutableList类及其of()与copyOf()工厂方法:(参数不能为空)

  1. List<String> il = ImmutableList.of("string""elements");  // from varargs 
  2. List<String> il = ImmutableList.copyOf(aStringArray);      // from array 

对于可变集合,你可以使用Lists类及其newArrayList()工厂方法:

  1. List<String> l1 = Lists.newArrayList(anotherListOrCollection);    // from collection 
  2. List<String> l2 = Lists.newArrayList(aStringArray);               // from array 
  3. List<String> l3 = Lists.newArrayList("or""string""elements"); // from varargs 

5、使用 Apache Commons Collections

  1. List<String> list = new ArrayList<String>(); 
  2. CollectionUtils.addAll(list, str); 

6、 使用 Java9 的 List.of()方法

  1. Integer[] array = {1, 2, 3}; 
  2. List<Integer> list = List.of(array); 

原文链接:https://mp.weixin.qq.com/s/vp3I_icUbfbEj38LCZFKwQ

延伸 · 阅读

精彩推荐