Java流库（中篇——Optional、元素收集）

分手后的思念是犯贱 2023-10-10 19:48 4阅读 0赞

**Optional是一个包装器对象**，简单来说就是它内部包装了一个对象，**这个对象要么存在那么为null**，并且可以围绕这个对象做一些操作。

创建Optional

Optional提供了三种方式创建一个Optional

ini

复制代码

`Optional<Integer> of = Optional.of(1); Optional<Integer> ofNull = Optional.ofNullable(1); Optional<Object> empty = Optional.empty();`

上面的三行代码分别对应三种创建Optional对象的方式。**第一种使用`of(T val)`方法**，示例中使用这个方法创建一个包装了`Integer`的包装器对象`Optional`；第二种使用`ofNullable(T val)`，示例中使用这个方法创建了`Integer`的包装器对象`Optional`，**但是它与第一个方法不同的是，如果传入的值为`null`则创建一个空的Optional，而第一个方法则会抛出异常**；最后第三个方法表示创建一个空的包装器对象。

获取Optional中的值

java

复制代码

`Optional<Integer> first = cs2().filter(x -> x>8).findFirst(); int num1 = first.get(); int num2 = first.orElse(-1); int num3 = first.orElseGet(() -> -1); int num4 = first.orElseThrow(IllegalStateException::new);`

上面的示例中举例了四个获取`Optional`中元素的方法，其中`get`方法不常用，如果元素不存在会直接抛出`NoSuchElementException`异常。`orElse`方法提供一个默认值，如果元素为空返回这个默认值。`orElseGet`的参数是一个`Supplier`函数式接口，可以返回任意类型的值，如果元素为空返回这个方法运行的结果。最后一个`orElseThrow`可以传递一个异常对象，如果元素不存在则会抛出异常。

通过ifPresent方法消费其包装的值

这个方法可以判断`Optional`中的值是否存在，如果存在将包装的值传递给参数中的`Consumer`接口的实例方法，这个`Consumer`会自动执行。

java

复制代码

`Optional<Integer> first = cs2().filter(x -> x>4).findFirst(); first.ifPresent(v -> System.out.println(v));`

> 输出：5

除了`ifPresent`方法外，还有一个方法叫做`ifPresentOrElse`，这个方法有两个参数，第一个参数是`Consumer`类型，第二个参数是`Runnable`类型的，总体的意思是如果元素不存在执行第一个动作，否则执行第二个动作。

java

复制代码

`Optional<Integer> first = cs2().filter(x -> x>8).findFirst(); first.ifPresentOrElse(System.out::println,() -> System.out.println("不存在数据"));`

> 输出：不存在数据

转换Optional值

**实际上`Optional`的转换操作跟流(Stream)的转换的转换操作是类似的**，只不过`Optional`只包含一个元素。

**代码示例：**

java

复制代码

`Optional<Integer> first = cs2().filter(x -> x>4).findFirst(); Optional<Double> aDouble = first.map(Integer::doubleValue); System.out.println(aDouble);`

> 输出：Optional\[5.0\]

flatMap

简单来说，`flatMap`的作用是把多个针对`Optional`的操作串联起来，当所有的操作都执行成功才算成功；任何一步失败则视为失败。

java

复制代码

`class HelloWorld { public static Optional<String> getHello(String msg) { // int i = 1/0; return Optional.of(msg); } public static Optional<String> getWorld(String msg) { return Optional.of(msg + "嘿嘿"); } }`

java

复制代码

`public static void main(String[] args) throws FileNotFoundException { Optional<String> o = Optional.of("你好朋友").flatMap(HelloWorld::getHello).flatMap(HelloWorld::getWorld); System.out.println(o); }`

> 输出：Optional\[你好朋友嘿嘿\]

上面的示例中，使用`flatMap`方法**将两个任务连接成一个任务，后面的任务需要依赖前面一个任务**。这个任务链最终成功执行。但是如果将`int i = 1/0;`这行注释去掉，则第一个任务会出错，并且任务链也会失败。

将Optional转换为流

java

复制代码

`Optional<String> o = Optional.of("你好朋友").flatMap(HelloWorld::getHello).flatMap(HelloWorld::getWorld); Stream<String> stream = Stream.of(o.get());`

通过`Stream`创建流的方法，很容易就可以配合包装器的`get()`完成新流的创建。

获取流的结果

以上所说的都关于如何操作流，那如果现在流已经完成了一系列任务，**该怎么获取到流中的数据呢？**

遍历流

可以通过forEach直接遍历流中的元素

java

复制代码

`public static void main(String[] args) throws FileNotFoundException { Stream<String> hello = Stream.of("hello", "kitty", "hello", "kitty"); hello.map(s -> s.concat(" ")).forEach(System.out::print); }`

> 输出：hello kitty hello kitty

通过流得到一个数组

java

复制代码

`public static void main(String[] args) throws FileNotFoundException { Stream<String> hello = Stream.of("hello", "kitty", "hello", "kitty"); // String[] strings = hello.toArray((x) -> new String[x]); //等同于上面的写法 String[] strings = hello.toArray(String[]::new); for (String s : strings) { System.out.print(s+" "); } }`

> 输出：hello kitty hello kitty

这里需要注意的是，`toArray()`方法的默认数组类型为`Object[]`。所以可以通过它的`IntFunction`类型参数指定一个具体的类型。

通过collect收集元素

收集流中的数据到`List`集合

java

复制代码

`Stream<String> hello = Stream.of("hello", "kitty", "hello", "kitty"); List<String> list = hello.collect(Collectors.toList());`

收集流中的数据到`Set`集合 **（无序且元素不可重复）**

java

复制代码

`Stream<String> hello = Stream.of("hello", "kitty", "hello", "kitty"); Set<String> set = hello.collect(Collectors.toSet());`

收集流中的数据到`TreeSet`集合 **（有序且无重复元素）**

arduino

复制代码

`Stream<String> hello = Stream.of("hello", "kitty", "hello", "kitty"); Set<String> set = hello.collect(Collectors.toCollection(TreeSet::new));`

> 这里的`toCollection`方法的作用是指定获得的集合的种类

收集流中的字符串并拼接他们

java

复制代码

`Stream<String> hello = Stream.of("hello", "kitty", "hello", "kitty"); String str = hello.collect(Collectors.joining(" "));`

收集元素到映射表(Map)中

arduino

复制代码

`Stream<String> hello = Stream.of("hello", "kitty", "hello", "kitty"); Map<String, String> map = hello.collect(Collectors.toMap(x -> x, x -> x));`

这个示例代码运行时会报错，因为`Map`中键不允许重复，遇到这种情况可以传入`toMap`方法的第三个参数来解决：

java

复制代码

`Stream<String> hello = Stream.of("hello", "kitty", "hello", "kitty"); Map<String, String> map = hello.collect(Collectors.toMap(x -> x, x -> x,(a,b)->"newVal")); System.out.println(map);`

> 输出：\{hello=newVal, kitty=newVal\}

第三个参数是一个函数式接口类型，**它的意思是说当遇到相同的`key`时，需要为其指定一个值来覆盖它，可以是原值和新值，也可以是自定义的值。**

默认的获取的`Map`类型为`HashMap`另外如果**想要得到其他`Map`类型**，还可以传入`toMap`方法的第四个参数：

java

复制代码

`Stream<String> hello = Stream.of("hello", "kitty", "hello", "kitty"); Map<String, String> map = hello.collect(Collectors.toMap(x -> x, x -> x,(a,b)->"newVal",TreeMap::new));`

分组统计流的数据

假如想**统计**流中的所有相同元素的个数该怎么办呢？

groupingBy方法

java

复制代码

`Stream<String> hello = Stream.of("hello", "kitty", "hello", "kitty"); Map<String, List<String>> map = hello.collect(Collectors.groupingBy(x -> x)); System.out.println(map);`

> 输出：\{hello=\[hello, hello\], kitty=\[kitty, kitty\]\}

`groupingBy`方法的参数是一个`Function`接口。他会按照这个函数式接口实例的方法返回值进行分组。比如返回`hello`就按`Hello`分组为`hello=[hello, hello]`

partitioningBy方法

这个方法的作用是按给定的条件将结果按`true`和`false`分别分组。**它们的键就是`true`或`false`。**

java

复制代码

`Stream<String> hello = Stream.of("hello", "kitty", "hello", "kitty"); Map<Boolean, List<String>> map = hello.collect(Collectors.partitioningBy(s -> s.equals("hello"))); System.out.println(map);`

> 输出：\{false=\[kitty, kitty\], true=\[hello, hello\]\}

可以看到，符合条件的元素都被映射到了`key`为`true`的`value`中，不符合条件的则映射到`key`为`false`的`value`中。

处理groupingBy分组中的数据

比如这么一个分组结果`{hello=[hello, hello], kitty=[kitty, kitty]}`，可不可以统计分组中元素的数量？

counting

java

复制代码

`Stream<String> hello = Stream.of("hello", "kitty", "hello", "kitty"); Map<String, Long> map = hello.collect(Collectors.groupingBy(x->x,Collectors.counting())); System.out.println(map);`

> 输出：\{hello=2, kitty=2\}

通过`Collectors`的静态方法`counting()`就可完成对每个分组中元素数量的统计

summingInt

这个方法可以计算出分组中数值类型的和

java

复制代码

`Stream<Integer> hello = Stream.of(2,3,4,4,2,3,5,6,4,4,7,8,8,8); Map<Integer, Integer> map = hello.collect(Collectors.groupingBy(x -> x,Collectors.summingInt(x -> x))); System.out.println(map);`

> 输出：\{2=4, 3=6, 4=16, 5=5, 6=6, 7=7, 8=24\}

maxBy、minBy

这两个静态方法可以产生分组中的**最大值和最小值**。例如下面的示例中，会产生出奇数以及偶数两个分组中的最大值。

java

复制代码

`Stream<Integer> hello = Stream.of(2,3,4,4,2,3,5,6,4,4,7,8,8,8); Map<Object, Optional<Integer>> map = hello.collect(Collectors.groupingBy(x -> x % 2,Collectors.maxBy(Comparator.comparing((x)-> x)))); System.out.println(map);`

> 输出：\{0=Optional\[8\], 1=Optional\[7\]\}

**`minBy`不做举例，两个方法用法是一样的**

collectingAndThen

**如果想要先收集分组中的元素再针对每个分组做计算**，就应该使用`collectingAndThen`

java

复制代码

`Stream<Integer> hello = Stream.of(2,3,4,4,2,3,5,6,4,4,7,8,8,8); Map<String, Integer> map = hello.collect(Collectors.groupingBy(x -> x % 2==0?"偶数":"奇数", Collectors.collectingAndThen(Collectors.toSet(), Set::size))); System.out.println(map);`

> 输出：\{偶数=4, 奇数=3\}

mapping

`mapping`方法的作用与`collectingAndThen`完全相反，它是先对分组做计算后收集计算后的每组元素。例如下面的代码会先将分组中的每个`Integer`类型的元素都`乘以2`，再收集到`Set`集合中。

java

复制代码

`Stream<Integer> hello = Stream.of(2,3,4,4,2,3,5,6,4,4,7,8,8,8); Map<String, Set<Integer>> map = hello.collect(Collectors.groupingBy(x -> x % 2 == 0 ? "偶数" : "奇数", Collectors.mapping((x) -> x * 2, Collectors.toSet()))); System.out.println(map);`

> 输出：\{偶数=\[16, 4, 8, 12\], 奇数=\[6, 10, 14\]\}

summarizingInt

这是一个非常好用的方法，他可以返回一个分组中元素的汇总对象；**在之后可以通过这个对象获取到分组中数据的总和、平均值、总数量、最大值、最小值**

java

复制代码

`Stream<Integer> hello = Stream.of(2,3,4,4,2,3,5,6,4,4,7,8,8,8); Map<String, IntSummaryStatistics> map = hello.collect(Collectors.groupingBy(x -> x % 2 == 0 ? "偶数" : "奇数", Collectors.summarizingInt((x) -> x))); Set<Map.Entry<String, IntSummaryStatistics>> entries = map.entrySet(); for (Map.Entry<String, IntSummaryStatistics> entry : entries) { System.out.println(entry.getKey()); System.out.print("平均值："+entry.getValue().getAverage()+"、"); System.out.print("总和："+entry.getValue().getSum()+"、"); System.out.print("数量："+entry.getValue().getCount()+"、"); System.out.print("最大值："+entry.getValue().getMax()+"\n"); }`

> 输出：偶数  
> 平均值：5.0、总和：50、数量：10、最大值：8  
> 奇数  
> 平均值：4.5、总和：18、数量：4、最大值：7

filtering

**还可以对分组的数据使用过滤器**，下面的示例会筛选出分组中小于`5`的数值

java

复制代码

`Stream<Integer> hello = Stream.of(2,3,4,4,2,3,5,6,4,4,7,8,8,8); Map<String, List<Integer>> map = hello.collect(Collectors.groupingBy(x -> x % 2 == 0 ? "偶数" : "奇数", Collectors.filtering(x -> x < 5, Collectors.toList()))); System.out.println(map);`

> 输出：\{偶数=\[2, 4, 4, 2, 4, 4\], 奇数=\[3, 3\]\}

作者：现在没有牛仔了  
链接：https://juejin.cn/post/7234894309995921469  
来源：稀土掘金  
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。