JDK8随笔

编程

Stream还可以像数据库的操作那样处理数据:比如分组、分区、汇总等等。

导入Collectors类中的所有静态方法,使用时不再需要Collectors.去调用,直接使用即可:

importstatic java.util.stream.Collectors.*;

 

1、数据分组: groupingBy

List<String> views = Lists.newArrayList("wsbs","xafaswzx","b8fw","ad");

Map<Integer, List<String>> res = views.stream().collect(groupingBy(String::length));

//{2=[ad], 4=[wsbs, b8fw], 8=[xafaswzx]}

 

2、将收集的结果转换为另一种类型: collectingAndThen

Map<Integer, Object> res = views.stream().collect(

              groupingBy(String::length, Collectors.collectingAndThen(                 

                        Collectors.maxBy(Comparator.comparingInt(String::length)),

                       Optional::get  // 为转换函数,转换最终的数据 

              ))

);

System.out.println(res);

// {2=ad, 4=wsbs, 8=xafaswzx}

 

3、多级分组: 嵌套使用groupingBy即可

List<String> views = Lists.newArrayList("wsbsq","hello word","b8fw", "word", "wall", "ad");

Map<Object, Map<Object, List<String>>> res = views.stream()

                                          .collect(groupingBy(str -> str.charAt(0), groupingBy(String::length)));

System.out.println(res);

// {a={2=[ad]}, b={4=[b8fw]}, w={4=[word, wall], 5=[wsbsq]}, h={10=[hello word]}}

 

4、统计子组数据

List<String> views = Lists.newArrayList("wsbsq","hello word","b8fw", "word", "wall", "ad");

Map<Integer, Long> res = views.stream()

                                     .collect(groupingBy(String::length, Collectors.counting()));

System.out.println(res);

// {2=1, 4=3, 5=1, 10=1}

 

5、数据分区: partitioningBy

分区函数必须返回一个boolean值,也就是说最后的分区组一个是true,一个是false。

List<String> views = Lists.newArrayList("wsbs","1232","b8fw","wsad");

Map<Boolean, List<String>> res = views.stream().collect(

                                                     partitioningBy(str -> str.startsWith("ws")));

//{false=[1232, b8fw], true=[wsbs, wsad]}

 

// 分区中再进行分组

Map<Boolean, Map<Object, List<String>>> res = views.stream().collect(Collectors.partitioningBy(str -> str.startsWith("ws"),

Collectors.groupingBy(String::length)));

 

//{false={3=[232], 6=[b8sdfw]}, true={2=[ws], 4=[wsad]}}

 

6、转换成值:maxBy、minBy

List<String> views = Lists.newArrayList("wsbs","xafaswzx","b8fw","ad");

Optional<String> res = views.stream().collect(

                                minBy(Comparator.comparing(String::length)));

System.out.println(res.get());  //ad

minBy的最终实现: (a, b) -> comparator.compare(a, b) <= 0 ? a : b

maxBy的最终实现: (a, b) -> comparator.compare(a, b) >= 0 ? a : b

 

7、将流中的数据转换成整型后汇总求和: summingInt

List<String> views = Lists.newArrayList("wsbs","xafaswzx","b8fw","ad");

Integer resInt = views.stream()

                 .collect(summingInt(String::length));

System.out.println(resInt);  //18

若为summingLong,同样输出18

若为summingDouble,则输出18.0

 

8、拼接字符串: joining 

// wsbs-xafaswzx-b8fw-ad

System.out.println(views.stream().map(s -> s).collect(joining("-")));

 

9、映射: mapping(Person::getLastName, toSet())

即mapping操作可将左参数(lambda表达式,用于对流中元素做变换)产生的数据动态记录到右参数(集合,将变换的结果收集到集合)中,其内部实现也是通过工厂容器 + 累加器 + 组合器来实现的。

而和groupingBy一起使用的收集器一般也是由mapping方法生成的,当然也包含其他方法。

 

10、Collectors类中的静态工厂方法:

工厂方法

返回类型

用于

toList

List<T>

 把流中的所有数据元素收集到List集合中。

stream.collect(toList());

 toSet

Set<T>

 把流中的所有数据元素收集到Set集合中,以为Set自身的特性,即不会出现重复

项。stream.collect(toSet());

 toCollection

Collection<T>

 把流中的数据元素收集你所指定的集合中,

list.stream().collect(toCollection(ArrayList::new));

 counting

Long

 计算流中元素的个数,list.stream().collect(counting());

 summingInt

Integer

 对流中所有元素上指定的整数属性求和,

list.stream().collect(summingInt(User::getAge));

 averagingInt

Double

 对流中所有元素上指定的整数属性求平均数,

list.stream().collect(averagingInt(User::getAge));

 summarizingInt

IntSummaryStatistics

 收集流中所有元素上指定的整数属性的统计值,包括最大值、最小值、总数、平均值。

list.stream().collect(summarizingInt(User::getAge));

joining

String

 连接流中元素上指定的属性,

list.stream().map(s -> s).collect(joining("-"))

 maxBy

Optional<T>

使用指定的比较器去比较得到流中所有元素上指定属性的最大值,

list.stream().collect(maxBy(Comparator.comparing(String::length)))

 minBy

Optional<T>

使用指定的比较器去比较得到流中所有元素上指定属性的最小值,

list.stream().collect(minBy(Comparator.comparing(String::length)))

 reducing

规约操作产生的类型

从一个累加器的初始值开始,使用BinaryOperator与流中的元素逐个集合,最后将流规约为单个值。

list.stream().collect(reducing(0, UserVO::getAge, Integer::sum));

 collectingAndThen

 转换函数返回的类型

 对最终结果转换为另一种类型,

list.stream().collect(collectingAndThen(Collectors.toList(), List::size));

 groupingBy

 Map<k, List<T>>

 根据指定的属性来分组,

views.stream().collect(groupingBy(String::length));

 partitioningBy

 Map<boolean, List<T>>

 根据指定的属性来分区,

 views.stream().collect(partitioningBy(str -> str.startsWith("ws"))

 

11、11interface Collector<T, A, R>

 当遇到不同的业务需求时,可能会需要自己去实现收集器的功能,就必须得实现Collector接口了,大概包含如下几个方法:

 

1)Supplier<A> supplier();

      用于创建并返回一个新的可变结果的容器。

 

2)BiConsumer<A, T> accumulator();

      将元素添加到结果容器中。

 

3)BinaryOperator<A> combiner();

      合并两个结果容器。

 

4)Function<A, R> finisher();

      对结果容器应用最终转换。      

 

5)Set<Characteristics> characteristics();

      返回一个不可变的Characteristics集合。

      其中Characteristics为一个枚举类,包含这3个值:CONCURRENT、UNORDERED、IDENTITY_FINISH。

      UNORDERED:归约结果不受流中项目的遍历和累积顺序的影响。

      CONCURRENT:支持多线程同时调用,可进行并行归约,但只有在没有被标识为UNORDERED才用于无序数据源的并行归约。

       IDENTITY_FINISH:表示finisher函数返回的是一个恒等函数,可以不用设置。

以上是 JDK8随笔 的全部内容, 来源链接: utcz.com/z/518327.html

回到顶部