自从用了 Stream，代码更简洁优雅了！

前言

虽然 stream在 Java8 中就已经被引入，但是大多数人却没有去使用这个十分有用的特性，本文就通过介绍几个通过使用stream让代码更简洁、可读，来让你了解stream的方便之处。
技巧

数组转集合

相信经常刷LeetCode的小伙伴，偶尔会遇到需要将List与基本类型数组进行互转的情况，然后就需要写像下面这样的代码：

1. // 将 List 元素存储到数组中
2. List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
3. int[] arr = new int[list.size()];
4. Integer[] temp = list.toArray(new Integer[0]);
5. for (int i = 0; i < temp.length; i++) {
6. arr[i] = temp[i];
7. }
9. // 将数组元素 存储到 List 中
10. int[] arr = {1, 2, 3, 4, 5};
11. List<Integer> list = new ArrayList<>();
12. for (int val : arr) {
13. list.add(val);
14. }

复制代码

以上两个转换虽然写着还不算麻烦，但是每次都需要写一个循环，尤其在数组转List的时候还需要使用一个临时数组，都会让人看着很不舒服，但是如果使用了stream就会大不一样，用stream实现了相同功能的代码如下：

1. // 将 List 元素存储到数组中
2. List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
3. int[] arr = list.stream().mapToInt(Integer::intValue).toArray();
5. // 将数组元素 存储到 List 中
6. int[] arr = {1, 2, 3, 4, 5};
7. List<Integer> list = IntStream.of(arr).boxed().collect(Collectors.toList());

复制代码

可以发现通过使用stream，我们能够在写代码的时候更加连贯，代码也更加可靠易维护，注意力也可以放在业务功能上，相信各位就算对lambda语法并不是太熟悉，在阅读上面代码的时候，也很容易能够看懂。
统计数组元素中的个数

假设我们现在需要统计并输出一个有重复元素的数组中每个元素及对应元素出现的个数，相信各位都能够想到，我们使用一个Map就很容易解决这个问题，代码如下：

1. String[] arr = {"a", "c", "a", "b", "d", "c"};
2. Map<String, Integer> map = new HashMap<>();
3. for (String s : arr) {
4.     if (map.containsKey(s)) {
5.         map.put(s, map.get(s) + 1);
6.     } else {
7.         map.put(s, 1);
8.     }
9. }
10. map.forEach((key, value) -> System.out.println(key + " : " + value));

复制代码

如果对Map中的API更加熟悉的小伙伴，可能会写出下面这个更加简洁的代码：

1. String[] arr = {"a", "c", "a", "b", "d", "c"};
2. Map<String, Integer> map = new HashMap<>();
3. for (String s : arr) {
4.     map.put(s, map.getOrDefault(s, 0) + 1);
5. }
6. map.forEach((key, value) -> System.out.println(key + " : " + value));

复制代码

但是，如果使用stream，我们还能写出更加简洁的代码，同样不需要写烦人的循环了，而且只需两行代码即可(为了提高可读性，进行了换行)：

1. String[] arr = {"a", "c", "a", "b", "d", "c"};
2. Stream.of(arr)
3.       .collect(Collectors.toMap(k -> k, k -> 1, Integer::sum))
4.       .forEach((k, v) -> System.out.println(k + " : " + v));

复制代码

注意

在上面的代码中，Collectors.toMap(k -> k, k -> 1, Integer::sum)这一部分可能不好理解，对于这里面的三个参数，第一个参数代表将arr中的每一个元素作为Map中的key，第二个参数代表每一个key所对应的value，在这里每一个元素都对应个数1，第三个参数代表，如果存在相同的key，该如何进行合并，这里通过使用Integer::sum，代表将具有相同key的元素进行合并时，其value进行相加，这样便实现了每个元素个数的统计。
基本数据类型的数组自定义排序

有时我们会遇到对基本数据类型的数组进行自定义排序的情况，不同于包装类型的数组和集合可以直接使用比较器，我们只能通过将基本数组类型的数组转为包装类型或者存储在集合中，在排序完成后再转为基本类型的数组，再者，我们只能通过手写排序算法，修改排序算法中的比较进行实现。
不管是哪种方法，我们都没办法将精力放在逻辑功能上，必须写一些额外的代码，甚至是修改底层逻辑，就像下面的代码一样（实现数组逆序）：

1. int[] arr = {1, 5, 9, 7, 2, 3, 7, -1, 0, 3};
2. // 将数组转为包装类型再进行自定义排序
3. Integer[] temp = new Integer[arr.length];
4. for (int i = 0; i < arr.length; i++) {
5.     temp[i] = arr[i];
6. }
7. Arrays.sort(temp, Comparator.reverseOrder());
8. for (int i = 0; i < temp.length; i++) {
9.     arr[i] = temp[i];
10. }
12. // 将数组转为集合类型再进行自定义排序
13. List<Integer> list = new ArrayList<>();
14. for (int val : arr) {
15.     list.add(val);
16. }
17. list.sort(Collections.reverseOrder());
18. for (int i = 0; i < list.size(); i++) {
19.     arr[i] = list.get(i);
20. }
22. // 通过手写排序算法修改比较规则实现
23. // 为了让代码更加简洁，使用了最暴力且没有优化的冒泡排序
24. int[] arr = {1, 5, 9, 7, 2, 3, 7, -1, 0, 3};
25. for (int i = 0; i < arr.length; i++) {
26.     for (int j = 0; j < arr.length - i - 1; j++) {
27.         if (arr[j] < arr[j + 1]) {
28.             int temp = arr[j];
29.             arr[j] = arr[j + 1];
30.             arr[j + 1] = temp;
31.         }
32.     }
33. }

复制代码

可以发现以上几种方法，我们都需要写很多代码，无法将注意力集中在设计自定义排序这个问题上，但是通过使用stream，我们就可以写出下面这样简洁的代码(如果愿意的话，你也可以把一系列的链式操作写在一行上，但为了代码的可读性，不建议那么做)：

1. int[] arr = {1, 5, 9, 7, 2, 3, 7, -1, 0, 3};
2. arr = IntStream.of(arr)
3.                .boxed()
4.                .sorted(Comparator.reverseOrder())
5.                .mapToInt(Integer::intValue)
6.                .toArray();

复制代码

注意

在这里其实为了实现数组的逆序，我们只需要调用Arrays的sort方法，然后再进行数组元素的反转即可，不过因为是为了讲解自定义排序，大多数情况下不会是数组逆序这么简单，所以我就写了更加通用一些的代码。
统计数组中前 k 个个高频元素

在最后，我们通过一道题来进行实战以便更好的体验stream的强大之处，当然我们在练习该题的时候，更需要从算法的角度去考虑该题的解法，不过在本文，我们主要为了讲解stream的使用，所以就不去考虑算法的东西了，而如果使用stream，我们就可以写出下面这样简单易懂的代码：

1. class Solution {
2.     public int[] topKFrequent(int[] nums, int k) {
3.         return Arrays.stream(nums)
4.                      .boxed()
5.                      .collect(Collectors.toMap(e -> e, e -> 1, Integer::sum))
6.                      .entrySet()
7.                      .stream()
8.                      .sorted((m1, m2) -> m2.getValue() - m1.getValue())
9.                      .limit(k)
10.                      .mapToInt(Map.Entry::getKey)
11.                      .toArray();
12.     }
13. }

复制代码

总结

本文介绍了几个简单、实用的stream使用技巧，当然stream的应用远不止此，希望通过本文，能够激发起你学习stream的兴趣，本文若有错误之处，也欢迎你的指正。
近期热文推荐：
1.1,000+ 道 Java面试题及答案整理(2022最新版)
2.劲爆！Java 协程要来了。。。
3.Spring Boot 2.x 教程，太全了！
4.别再写满屏的爆爆爆炸类了，试试装饰器模式，这才是优雅的方式！！
5.《Java开发手册（嵩山版）》最新发布，速速下载！
觉得不错，别忘了随手点赞+转发哦！