集合判空
判断所有集合内部的元素是否为空,使用 isEmpty() 方法,而不是 size()==0 的方式
这是因为 isEmpty()
方法的可读性更好,并且时间复杂度为 O(1)。
绝大部分我们使用的集合的 size()
方法的时间复杂度也是 O(1),不过,也有很多复杂度不是 O(1) 的,比如 java.util.concurrent
包下的某些集合(ConcurrentLinkedQueue
、ConcurrentHashMap
…)。
下面是 ConcurrentHashMap
的 size()
方法和 isEmpty()
方法的源码。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 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; } } return sum; }public boolean isEmpty () { return sumCount() <= 0L ; }
集合转Map
在使用 java.util.stream.Collectors
类的 toMap()
方法转为 Map
集合时,一定要注意当 value 为 null 时会抛 NPE 异常。
1 2 3 4 5 6 7 8 9 10 11 12 class Person { private String name; private String phoneNumber; } List<Person> bookList = new ArrayList <>(); bookList.add(new Person ("jack" ,"18163138123" )); bookList.add(new Person ("martin" ,null )); bookList.stream().collect(Collectors.toMap(Person::getName, Person::getPhoneNumber));
首先,我们来看 java.util.stream.Collectors
类的 toMap()
方法 ,可以看到其内部调用了 Map
接口的 merge()
方法。
1 2 3 4 5 6 7 8 9 10 11 public static <T, K, U, M extends Map <K, U>> Collector<T, ?, M> toMap(Function<? super T, ? extends K > keyMapper, Function<? super T, ? extends U > valueMapper, BinaryOperator<U> mergeFunction, Supplier<M> mapSupplier) { BiConsumer<M, T> accumulator = (map, element) -> map.merge(keyMapper.apply(element), valueMapper.apply(element), mergeFunction); return new CollectorImpl <>(mapSupplier, accumulator, mapMerger(mergeFunction), CH_ID); }
Map
接口的 merge()
方法如下,这个方法是接口中的默认实现。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 default V merge (K key, V value, BiFunction<? super V, ? super V, ? extends V> 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 是否为空。
1 2 3 4 5 6 public static <T> T requireNonNull (T obj) { if (obj == null ) throw new NullPointerException (); return obj; }
集合遍历
不要在 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 2 3 4 5 6 7 List<Integer> list = new ArrayList <>();for (int i = 1 ; i <= 10 ; ++i) { list.add(i); } list.removeIf(filter -> filter % 2 == 0 ); System.out.println(list);
除了上面介绍的直接使用 Iterator
进行遍历操作之外,你还可以:
使用普通的 for 循环
使用 fail-safe 的集合类。java.util
包下面的所有的集合类都是 fail-fast 的,而java.util.concurrent
包下面的所有的类都是 fail-safe 的。
…..
集合去重
可以利用 Set
元素唯一的特性,可以快速对一个集合进行去重操作,避免使用 List
的 contains()
进行遍历去重或者判断包含操作。
这里我们以 HashSet
和 ArrayList
为例说明。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 public static <T> Set<T> removeDuplicateBySet (List<T> data) { if (CollectionUtils.isEmpty(data)) { return new HashSet <>(); } return new HashSet <>(data); }public static <T> List<T> removeDuplicateByList (List<T> data) { if (CollectionUtils.isEmpty(data)) { return new ArrayList <>(); } List<T> result = new ArrayList <>(data.size()); for (T current : data) { if (!result.contains(current)) { result.add(current); } } return result; }
两者的核心差别在于 contains()
方法的实现。
HashSet
的 contains()
方法底部依赖的 HashMap
的 containsKey()
方法,时间复杂度接近于 O(1)(没有出现哈希冲突的时候为 O(1))。
我们有 N 个元素插入进 Set 中,那时间复杂度就接近是 O (n)。
ArrayList
的 contains()
方法是通过遍历所有元素的方法来做的,时间复杂度接近是 O(n)。
集合转数组
使用集合转数组的方法,必须使用集合的 toArray(T[] array)
,传入的是类型完全一致、长度为 0 的空数组。
toArray(T[] array)
方法的参数是一个泛型数组,如果 toArray
方法中没有传递任何参数的话返回的是 Object
类 型数组。
1 2 3 4 5 6 7 8 String [] s= new String []{ "dog" , "lazy" , "a" , "over" , "jumps" , "fox" , "brown" , "quick" , "A" }; List<String> list = Arrays.asList(s); Collections.reverse(list); s=list.toArray(new String [0 ]);
由于 JVM 优化,new String[0]
作为Collection.toArray()
方法的参数现在使用更好,new String[0]
就是起一个模板的作用,指定了返回数组的类型,0 是为了节省空间,因为它只是为了说明返回的类型。
数组转集合
使用工具类 Arrays.asList()
把数组转换成集合时,不能使用其修改集合相关的方法, 它的 add/remove/clear
方法会抛出 UnsupportedOperationException
异常。
Arrays.asList()
在平时开发中还是比较常见的,我们可以使用它将一个数组转换为一个 List
集合。
JDK 源码对于这个方法的说明:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 public static <T> List<T> asList (T... a) { return new ArrayList <>(a); }
1、Arrays.asList()
是泛型方法,传递的数组必须是对象数组,而不是基本类型。
1 2 3 4 5 6 7 8 int [] myArray = {1 , 2 , 3 };List myList = Arrays.asList(myArray); System.out.println(myList.size()); System.out.println(myList.get(0 )); System.out.println(myList.get(1 ));int [] array = (int []) myList.get(0 ); System.out.println(array[0 ]);
当传入一个原生数据类型数组时,Arrays.asList()
的真正得到的参数就不是数组中的元素,而是数组对象本身!此时 List
的唯一元素就是这个数组,这也就解释了上面的代码。
2. 使用集合的修改方法: add()
、remove()
、clear()
会抛出异常。
1 2 3 4 5 List myList = Arrays.asList(1 , 2 , 3 ); myList.add(4 ); myList.remove(1 ); myList.clear();
Arrays.asList()
方法返回的并不是 java.util.ArrayList
,而是 java.util.Arrays
的一个内部类,这个内部类并没有实现集合的修改方法或者说并没有重写这些方法。
1 2 3 List myList = Arrays.asList(1 , 2 , 3 ); System.out.println(myList.getClass());
这个内部类继承自AbstractList,实现了RandomAccess, Serializabl接口。
我们再看一下java.util.AbstractList
的 add/remove/clear
方法就知道为什么会抛出 UnsupportedOperationException
了。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 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<E> it = listIterator(fromIndex); for (int i=0 , n=toIndex-fromIndex; i<n; i++) { it.next(); it.remove(); } }
那么,那我们如何正确的将数组转换为 ArrayList
?
1、手动实现工具类
1 2 3 4 5 6 7 8 9 10 11 12 13 14 static <T> List<T> arrayToList (final T[] array) { final List<T> l = new ArrayList <T>(array.length); for (final T s : array) { l.add(s); } return l; } Integer [] myArray = { 1 , 2 , 3 }; System.out.println(arrayToList(myArray).getClass());
2、最简便的方法
1 List list = new ArrayList <>(Arrays.asList("a" , "b" , "c" ))
3、使用 Java8 的 Stream
(推荐)
1 2 3 4 5 6 Integer [] myArray = { 1 , 2 , 3 };List myList = Arrays.stream(myArray).collect(Collectors.toList());int [] myArray2 = { 1 , 2 , 3 };List myList = Arrays.stream(myArray2).boxed().collect(Collectors.toList());
4、使用 Guava
对于不可变集合,你可以使用ImmutableList类及其of()与copyOf()工厂方法:(参数不能为空)
1 2 List<String> il = ImmutableList.of("string" , "elements" ); List<String> il = ImmutableList.copyOf(aStringArray);
对于可变集合,你可以使[Lists
类及其newArrayList()
工厂方法:
1 2 3 List<String> l1 = Lists.newArrayList(anotherListOrCollection); List<String> l2 = Lists.newArrayList(aStringArray); List<String> l3 = Lists.newArrayList("or" , "string" , "elements" );
5、使用 Apache Commons Collections
1 2 List<String> list = new ArrayList <String>(); CollectionUtils.addAll(list, str);
6、 使用 Java9 的 List.of()
方法
1 2 Integer[] array = {1 , 2 , 3 }; List<Integer> list = List.of(array);
引用 (1) https://javaguide.cn/java/collection/java-collection-precautions-for-use.html#%E6%95%B0%E7%BB%84%E8%BD%AC%E9%9B%86%E5%90%88