【Java8实战】流的操作

悠悠 2023-06-30 01:51 17阅读 0赞

#### 引言 ####

通过上篇博客，我们对流有了一定了解，本篇博客将会通过一些代码来熟悉流的各种操作。主要包括：筛选、切片、映射、查找、匹配和归约。

#### 筛选和切片 ####

**(1) 用谓词筛选**

Streams接口支持filter方法，该操作会接受一个谓词（一个返回 boolean的函数）作为参数，并返回一个包括所有符合谓词的元素的流。

例如：筛选出所有素菜，创建一张素食菜单，代码如下：

//filter（筛选所有素食）
    List<Food> vegetarianMenu = menu.stream().filter(Food::isVegetarian) .collect(toList());
    System.out.println(vegetarianMenu.toString());

**(2) 筛选各异的元素**

流还支持一个叫作distinct的方法，它会返回一个元素各异（根据流所生成元素的 hashCode和equals方法实现）的流。

例如：从一组数中筛选出所有的偶数，并去重，代码如下：

// distinct（筛选所有偶数，并去重）
    List<Integer> numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4);
    numbers.stream().filter(i -> i % 2 == 0).distinct().forEach(System.out::println);

**(3) 截短流**

流支持limit(n)方法，该方法会返回一个不超过给定长度的流。所需的长度作为参数传递 给limit。如果流是有序的，则多会返回前n个元素。

例如：从一组食物中，筛选出卡路里大于300的前三道食物，代码如下：

//limit（筛选卡路里大于300的三种食物）
    List<Food> foods = menu.stream()
            .filter(d -> d.getCalories() > 300)
            .limit(3)
            .collect(toList());
    System.out.println(foods.toString());

**(4) 跳过元素**

流还支持skip(n)方法，返回一个扔掉了前n个元素的流。如果流中元素不足n个，则返回一个空流。

例如：从一组食物中，跳过前两个卡路里大于300的食物，返回剩下的，代码如下：

//skip（跳过前两个卡路里大于300的食物，返回剩下的）
    List<Food> foodList = menu.stream()
            .filter(d -> d.getCalories() > 300)
            .skip(2)
            .collect(toList());
    System.out.println(foodList.toString());

**练习：前两个荤菜**

//filter、limit（前两个荤菜）
    List<Food> meats = menu.stream()
            .filter(d -> d.getType() == Food.Type.MEAT)
            .limit(2)
            .collect(toList());
    System.out.println(meats);

#### 映射 ####

另一个非常常见的数据处理就是从某些对象中选择信息。比如在SQL里，你可以从表中选择一列。Stream API也通过map和flatMap方法提供了类似的工具。

**(1) map的使用：对流中每一个元素应用函数**

流支持map方法，它会接受一个函数作为参数。这个函数会被应用到每个元素上，并将其映射成一个新的元素。

例如：提取所有食物的名称

//map（提取所有食物的名称）
    List<String> dishNames = menu.stream().map(Food::getName).collect(toList());
    System.out.println(dishNames);

给定一个单词列表，想要返回另一个列表，显示每个单词中有几个字母，可以怎么做呢？我们也可以用map去实现。

//map (获取字符串数组中每个元素的字符长度）
    List<String> words = Arrays.asList("Java 8", "Lambdas", "In", "Action");
    List<Integer> wordLengths = words.stream()
                                     .map(String::length)
                                     .collect(toList());
    System.out.println(wordLengths);

如果你要找出每道菜的名称有多长，怎么做？我们可以像下面这样，再链接一个map：

//map（获取所有食物名称的长度）
    List<Integer> dishNameLengths = menu.stream()
                                        .map(Food::getName)
                                        .map(String::length)
                                        .collect(toList());
    System.out.println(dishNameLengths);

**(2) flatMap的使用：流的扁平化**

使用flatMap方法的效果是，各个数组并不是分别映射成一个流，而是映射成流的内容。所有使用map(Arrays::stream)时生成的单个流都被合并起来，即扁平化为一个流。

如果要列出一个字符串数组中，所有不同的字符，如何做？我们可能最开始想到的是使用map，代码如下：

//map（不正确的返回所有不相同的字符）
    List<String> wordList = Arrays.asList("Hello","World");
    List<String[]> allWord = wordList.stream()
                                     .map(word -> word.split(""))
                                     .distinct()
                                     .collect(toList());
    System.out.println(allWord);

但使用map返回的结果是List<String\[\]>，并不是我们想要的字符串List，使用flatMap便可以解决这个问题，代码如下：

//flatMap（输出所有不相同的字符）
    List<String> uniqueCharacters = wordList.stream()
                                         .map(w -> w.split(""))
                                         .flatMap(Arrays::stream)
                                         .distinct()
                                         .collect(Collectors.toList());
    System.out.println(uniqueCharacters);

#### 查找和匹配 ####

另一个常见的数据处理是看看数据集中的某些元素是否匹配一个给定的属性。Stream API通过allMatch、anyMatch、noneMatch、findFirst和findAny方法提供了这样的工具。

**(1) 检查谓词是否至少匹配一个元素**

anyMatch方法可以回答“流中是否有一个元素能匹配给定的谓词”。

比如，你可以用它来看看菜单里面是否有素食可选择，代码如下：

//anyMatch
    if(menu.stream().anyMatch(Food::isVegetarian)){     System.out.println("The menu is (somewhat) vegetarian friendly!!"); }

anyMatch方法返回一个boolean，因此是一个终端操作。

**(2) 检查谓词是否匹配所有元素**

allMatch可用来查看流中的元素是否都能匹配给定的谓词。

比如，用它来检查是否所有的食物卡路里都低于1000，代码如下：

//allMatch
    boolean isHealthy = menu.stream().allMatch(d -> d.getCalories() < 1000);
    System.out.println(isHealthy);

和allMatch相对的是noneMatch。它可以确保流中没有任何元素与给定的谓词匹配。

比如，将上述方法使用noneMatch重写：

//noneMatch
    boolean isHealthy2 = menu.stream().noneMatch(d -> d.getCalories() >= 1000);
    System.out.println(isHealthy2);

**(3) 查找元素**

findAny方法将返回当前流中的任意元素。它可以与其他流操作结合使用。

比如，筛选一道素菜，代码如下：

//findAny
    Optional<Food> food =menu.stream().filter(Food::isVegetarian).findAny();
    System.out.println(food);

**(4) 查找第一个元素**

有些流有一个出现顺序（encounter order）来指定流中项目出现的逻辑顺序（比如由List或排序好的数据列生成的流）。对于这种流，你可能想要找到第一个元素。

比如，给定一个数字列表，下面的代码能找出第一个平方能被3整除的数：

//findFirst
    List<Integer> someNumbers = Arrays.asList(1, 2, 3, 4, 5);
    Optional<Integer> firstSquareDivisibleByThree = someNumbers.stream()
                                                               .map(x -> x * x)
                                                               .filter(x -> x % 3 == 0)
                                                               .findFirst(); // 9
    System.out.println(firstSquareDivisibleByThree);

#### 规约 ####

以上操作的结果都是返回Boolean(allMatch等)、void(foreach)或Optional对象(findAny等)。下面的操作主要是将流中所有元素反复结合，得到一个值，这样的查询可以被归类为归约操作 （将流归约成一个值）。

**(1) 元素求和**

//遍历求和
    int sum1 = 0; for (int x : someNumbers) {     sum1 += x; }
    System.out.println(sum1);
    //reduce求和
    int sum2 = someNumbers.stream().reduce(0, (a, b) -> a + b);
    System.out.println(sum2);

reduce接受两个参数：

一个初始值，这里是0；

一个BinaryOperator来将两个元素结合起来产生一个新值，这里用的是 lambda (a, b) -> a + b。

**(2) 最大值和最小值**

我们可以使用reduce直接筛选得到一组数中的最大值与最小值，代码如下：

//最大值
    Optional<Integer> max = someNumbers.stream().reduce(Integer::max);
    System.out.println(max);
    
    //最小值
    Optional<Integer> min = someNumbers.stream().reduce(Integer::min);
    System.out.println(min);

#### 总结 ####

通过本篇博客的示例，对流的常用的一些操作filter，map，reduce等，应该是更加熟悉并且掌握了其对应的使用场景及方法，有机会可以在项目中实践起来了。

以上示例代码已更新至github，地址：[java8流操作学习][java8]

[java8]: https://github.com/huzhiting/java8-learning