Java流库（中篇——Optional、元素收集）
Optional是一个包装器对象，简单来说就是它内部包装了一个对象，这个对象要么存在那么为null，并且可以围绕这个对象做一些操作。
创建Optional
Optional提供了三种方式创建一个Optional
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中的值
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会自动执行。
Optional<Integer> first = cs2().filter(x -> x>4).findFirst();
first.ifPresent(v -> System.out.println(v));
输出：5
除了ifPresent方法外，还有一个方法叫做ifPresentOrElse，这个方法有两个参数，第一个参数是Consumer类型，第二个参数是Runnable类型的，总体的意思是如果元素不存在执行第一个动作，否则执行第二个动作。
Optional<Integer> first = cs2().filter(x -> x>8).findFirst();
first.ifPresentOrElse(System.out::println,() -> System.out.println("不存在数据"));
输出：不存在数据
转换Optional值
实际上Optional的转换操作跟流(Stream)的转换的转换操作是类似的，只不过Optional只包含一个元素。
代码示例：
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的操作串联起来，当所有的操作都执行成功才算成功；任何一步失败则视为失败。
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 + "嘿嘿");
}
}
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转换为流
Optional<String> o = Optional.of("你好朋友").flatMap(HelloWorld::getHello).flatMap(HelloWorld::getWorld);
Stream<String> stream = Stream.of(o.get());
通过Stream创建流的方法，很容易就可以配合包装器的get()完成新流的创建。
获取流的结果
以上所说的都关于如何操作流，那如果现在流已经完成了一系列任务，该怎么获取到流中的数据呢？
遍历流
可以通过forEach直接遍历流中的元素
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
通过流得到一个数组
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集合
Stream<String> hello = Stream.of("hello", "kitty", "hello", "kitty");
List<String> list = hello.collect(Collectors.toList());
收集流中的数据到Set集合 （无序且元素不可重复）
Stream<String> hello = Stream.of("hello", "kitty", "hello", "kitty");
Set<String> set = hello.collect(Collectors.toSet());
收集流中的数据到TreeSet集合 （有序且无重复元素）
Stream<String> hello = Stream.of("hello", "kitty", "hello", "kitty");
Set<String> set = hello.collect(Collectors.toCollection(TreeSet::new));
这里的
toCollection方法的作用是指定获得的集合的种类
收集流中的字符串并拼接他们
Stream<String> hello = Stream.of("hello", "kitty", "hello", "kitty");
String str = hello.collect(Collectors.joining(" "));
收集元素到映射表(Map)中
Stream<String> hello = Stream.of("hello", "kitty", "hello", "kitty");
Map<String, String> map = hello.collect(Collectors.toMap(x -> x, x -> x));
这个示例代码运行时会报错，因为Map中键不允许重复，遇到这种情况可以传入toMap方法的第三个参数来解决：
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方法的第四个参数：
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方法
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。
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
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
这个方法可以计算出分组中数值类型的和
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
这两个静态方法可以产生分组中的最大值和最小值。例如下面的示例中，会产生出奇数以及偶数两个分组中的最大值。
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
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集合中。
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
这是一个非常好用的方法，他可以返回一个分组中元素的汇总对象；在之后可以通过这个对象获取到分组中数据的总和、平均值、总数量、最大值、最小值
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的数值
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