Java8 Stream之Collectors

最新推荐文章于 2024-09-19 16:46:49 发布
最新推荐文章于 2024-09-19 16:46:49 发布
阅读量1.8k 收藏 2
点赞数
分类专栏： java基础 文章标签： Collectors
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012894692/article/details/117731276
版权

文章目录


Collectors 是 Java 8 加入的操作类，位于 java.util.stream 包下。它会根据不同的策略将元素收集归纳起来，比如最简单常用的是将元素装入 Map、Set、List等可变容器中

toList、toSet

Collector<T, ?, List<T>> toList() 
返回一个将输入元素累积到新List中的Collector

Collector<T, ?, Set<T>> toSet() 
返回一个将输入元素累积到新Set中的Collector

Stream<String> language = Stream.of("java", "php","java");
List<String> list = language.collect(Collectors.toList());
System.out.println(list);//[java, php, java]

Stream<String> language1 = Stream.of("java", "php","java");
Set<String> set = language1.collect(Collectors.toSet());
System.out.println(set);//[java, php]

toMap

Collector<T, ?, Map<K,U>> toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper)
返回一个将输入元素累积到新map中的Collector，keyMapper生成key的函数，valueMapper生成value的函数,当可以相同时报错java.lang.IllegalStateException: Duplicate key

Collector<T, ?, Map<K,U>> toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator<U> mergeFunction)
返回一个将输入元素累积到新map中的Collector，keyMapper生成key的函数，valueMapper生成value的函数,mergeFunction处理相同key的元素

Collector<T, ?, M> toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator<U> mergeFunction, Supplier<M> mapSupplier)
返回一个将输入元素累积到新map中的Collector，keyMapper生成key的函数，valueMapper生成value的函数,mergeFunction处理相同key的元素,mapSupplier一个函数，它返回一个新的指定实现类的空Map ，结果将插入其中

Stream<String> language2 = Stream.of("java", "php");
Map<String, Integer> map = language2.collect(Collectors.toMap(o -> o, o -> o.length()));
System.out.println(map);//{java=4, php=3}

Stream<String> language21 = Stream.of("java", "php","java");
Map<String, Integer> map21 = language21.collect(Collectors.toMap(o -> o, o -> o.length(), (o1, o2) ->  o1));
System.out.println(map21);//{java=4, php=3}

Stream<String> language22 = Stream.of("java", "php","java");
LinkedHashMap<String, Integer> map22 = language22.collect(Collectors.toMap(o -> o, o -> o.length(), (o1, o2) ->  o1, LinkedHashMap::new));
System.out.println(map22);//{java=4, php=3}

toConcurrentMap

和toMap相似，但是使用并发ConcurrentMap承装

Collector<T, ?, ConcurrentMap<K,U>> toConcurrentMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper)
返回一个将输入元素累积到新并发map中的Collector，keyMapper生成key的函数，valueMapper生成value的函数,当可以相同时报错java.lang.IllegalStateException: Duplicate key

Collector<T, ?, ConcurrentMap<K,U>> toConcurrentMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator<U> mergeFunction)
返回一个将输入元素累积到新map中的Collector，keyMapper生成key的函数，valueMapper生成value的函数,mergeFunction处理相同key的元素

Collector<T, ?, M> toConcurrentMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator<U> mergeFunction, Supplier<M> mapSupplier)
返回一个将输入元素累积到新map中的Collector，keyMapper生成key的函数，valueMapper生成value的函数,mergeFunction处理相同key的元素,mapSupplier一个函数，它返回一个新的指定实现类的空Map ，结果将插入其中

Stream<String> language4 = Stream.of("java", "php");
ConcurrentMap<String, Integer> concurrentMap = language4.collect(Collectors.toConcurrentMap(o -> o, o -> o.length()));
System.out.println(concurrentMap);//{java=4, php=3}

Stream<String> language41 = Stream.of("java", "php","java");
ConcurrentMap<String, Integer> concurrentMap1 = language41.collect(Collectors.toConcurrentMap(o -> o, o -> o.length(), (o1, o2) ->  o1));
System.out.println(concurrentMap1);//{java=4, php=3}

Stream<String> language42 = Stream.of("java", "php","java");
ConcurrentMap<String, Integer> concurrentMap2 = language42.collect(Collectors.toConcurrentMap(o -> o, o -> o.length(), (o1, o2) ->  o1, ConcurrentHashMap::new));
System.out.println(concurrentMap2);//{java=4, php=3}

toCollection

指定承装集合类型

Collector<T, ?, C> toCollection(Supplier<C> collectionFactory)
返回一个将输入元素累积到一个新的指定实现类的Collection中

Stream<String> language3 = Stream.of("java", "php","java");
ArrayList<String> arrayList = language3.collect(Collectors.toCollection(ArrayList::new));
System.out.println(arrayList);//[java, php, java]

joining

拼接元素

Collector<CharSequence, ?, String> joining() 
返回一个Collector ，它按照遇到的顺序将输入元素连接成一个String

Collector<CharSequence, ?, String> joining(CharSequence delimiter) 
返回一个以遇到顺序连接输入元素的Collector ，由指定的分隔符分隔

Collector<CharSequence, ?, String> joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix)
 返回一个Collector ，它按遇到顺序连接输入元素，由指定的分隔符分隔，具有指定的前缀和后缀

Stream<String> language = Stream.of("java", "php","java");
String joining = language.collect(Collectors.joining());
System.out.println(joining);//javaphpjava

Stream<String> language1 = Stream.of("java", "php","java");
String joining1 = language1.collect(Collectors.joining(","));
System.out.println(joining1);//java,php,java

Stream<String> language2 = Stream.of("java", "php","java");
String joining2 = language2.collect(Collectors.joining(",", "[", "]"));
System.out.println(joining2);//[java,php,java]

collectingAndThen

对Collector执行多次加工转换

Collector<T,A,RR> collectingAndThen(Collector<T,A,R> downstream, Function<R,RR> finisher) 
对Collector执行多次加工转换

Stream<String> language = Stream.of("java", "php","java");
String collectingAndThen = language.collect(Collectors.collectingAndThen(Collectors.joining(","), String::toUpperCase));
System.out.println(collectingAndThen);//JAVA,PHP,JAVA

groupingBy

对元素分组

Collector<T, ?, Map<K, List<T>>> groupingBy(Function<? super T, ? extends K> classifier)
对类型T输入元素执行“分组”操作,符合条件的元素将组成一个 List 映射到以T为key 的 Map 中

Collector<T, ?, Map<K, D>> groupingBy(Function<? super T, ? extends K> classifier, Collector<? super T, A, D> downstream)
对类型T输入元素执行“分组”操作,符合条件的元素将组成一个 集合 映射到以T为key 的 Map 中，downstream指定返回集合类型

Collector<T, ?, M> groupingBy(Function<? super T, ? extends K> classifier, Supplier<M> mapFactory, Collector<? super T, A, D> downstream)
对类型T输入元素执行“分组”操作,符合条件的元素将组成一个 集合 映射到以T为key 的 mapFactory新生成的map 中，downstream指定返回集合类型

Stream<String> language = Stream.of("java", "php","java");
Map<Integer, List<String>> map = language.collect(Collectors.groupingBy(String::length));
System.out.println(map);//{3=[php], 4=[java, java]}

Stream<String> language2 = Stream.of("java", "php","java");
Map<Integer, Set<String>> map2 = language2.collect(Collectors.groupingBy(String::length, Collectors.toSet()));
System.out.println(map2);//{3=[php], 4=[java]}

Stream<String> language3 = Stream.of("java", "php","java");
LinkedHashMap<Integer, Map<String, Integer>> map3 = language3.collect(Collectors.groupingBy(String::length, LinkedHashMap::new, Collectors.toMap(o -> o, o -> o.length(), (o1, o2) ->  o1)));
System.out.println(map3);//{4={java=4}, 3={php=3}}

groupingByConcurrent

分组后返回的是一个并发集合

Collector<T, ?, ConcurrentMap<K, List<T>>> groupingByConcurrent(Function<? super T, ? extends K> classifier)
对类型T输入元素执行“分组”操作,符合条件的元素将组成一个 List 映射到以T为key 的 并发Map 中

Collector<T, ?, ConcurrentMap<K, D>> groupingByConcurrent(Function<? super T, ? extends K> classifier, Collector<? super T, A, D> downstream)
对类型T输入元素执行“分组”操作,符合条件的元素将组成一个 集合 映射到以T为key 的 并发Map 中，downstream指定返回集合类型

Collector<T, ?, M> groupingByConcurrent(Function<? super T, ? extends K> classifier, Supplier<M> mapFactory, Collector<? super T, A, D> downstream)
对类型T输入元素执行“分组”操作,符合条件的元素将组成一个 集合 映射到以T为key 的 mapFactory新生成的并发map 中，downstream指定返回集合类型

Stream<String> language = Stream.of("java", "php","java");
Map<Integer, List<String>> map = language.collect(Collectors.groupingByConcurrent(String::length));
System.out.println(map);//{3=[php], 4=[java, java]}

Stream<String> language2 = Stream.of("java", "php","java");
Map<Integer, Set<String>> map2 = language2.collect(Collectors.groupingByConcurrent(String::length, Collectors.toSet()));
System.out.println(map2);//{3=[php], 4=[java]}

Stream<String> language3 = Stream.of("java", "php","java");
ConcurrentHashMap<Integer, Map<String, Integer>> map3 = language3.collect(Collectors.groupingByConcurrent(String::length, ConcurrentHashMap::new, Collectors.toMap(o -> o, o -> o.length(), (o1, o2) ->  o1)));
System.out.println(map3);//{3={php=3}, 4={java=4}}

partitioningBy

Collector<T, ?, Map<Boolean, List<T>>> partitioningBy(Predicate<? super T> predicate)
根据Predicate对输入元素进行判断分区，并将它们组织成Map<Boolean, List<T>>

Collector<T, ?, Map<Boolean, D>> partitioningBy(Predicate<? super T> predicate, Collector<? super T, A, D> downstream)
根据Predicate对输入元素进行判断分区，并将它们组织成Map<Boolean, ?<T>>,downstream指定返回集合类型

Stream<String> language = Stream.of("java", "php","java");
Map<Boolean, List<String>> map = language.collect(Collectors.partitioningBy(o -> o.length() > 3));
System.out.println(map);//{false=[php], true=[java, java]}

Stream<String> language2 = Stream.of("java", "php","java");
Map<Boolean, Set<String>> map2 = language2.collect(Collectors.partitioningBy(o -> o.length() > 3, Collectors.toSet()));
System.out.println(map2);//{false=[php], true=[java]}

counting

Collector<T, ?, Long> counting()
计算输入元素的数量。 如果不存在元素，则结果为 0。

Stream<String> language = Stream.of("java", "php","java");
Long count = language.collect(Collectors.counting());
System.out.println(count);//3

Stream.count() 实现相同功能

Stream<String> language = Stream.of("java", "php","java");
Long count = language.count();
System.out.println(count);//3

maxBy

Collector<T, ?, Optional<T>> maxBy(Comparator<? super T> comparator)
根据comparato比较后返回最大元素的Optional<T>

Stream<String> language = Stream.of("java", "php","java");
Optional<String> maxObj = language.collect(Collectors.maxBy(Comparator.comparingInt(String::length)));
System.out.println(maxObj.get());//java

Stream.max() 实现相同功能

Stream<String> language = Stream.of("java", "php","java");
Optional<String> max = language.max(Comparator.comparingInt(String::length));
System.out.println(max.get());//java

minBy

Collector<T, ?, Optional<T>> minBy(Comparator<? super T> comparator)
根据comparato比较后返回最小元素的Optional<T>

Stream<String> language = Stream.of("java", "php","java");
Optional<String> maxObj = language.collect(Collectors.minBy(Comparator.comparingInt(String::length)));
System.out.println(maxObj.get());//php

Stream.min() 实现相同功能

Stream<String> language = Stream.of("java", "php","java");
Optional<String> max = language.min(Comparator.comparingInt(String::length));
System.out.println(max.get());//php

summingXXX

Collector<T, ?, Double> summingDouble(ToDoubleFunction<? super T> mapper)
求输入元素的Double类型数值函数的总和
Collector<T, ?, Integer> summingInt(ToIntFunction<? super T> mapper)
求输入元素的Integer类型数值函数的总和
Collector<T, ?, Long> summingLong(ToLongFunction<? super T> mapper)
求输入元素的Long类型数值函数的总和

Stream<String> language = Stream.of("java", "php","java");
Double sumDouble = language.collect(Collectors.summingDouble(String::length));
System.out.println(sumDouble);//11.0

Stream<String> language2 = Stream.of("java", "php","java");
Integer sumInt = language2.collect(Collectors.summingInt(String::length));
System.out.println(sumInt);//11

Stream<String> language3 = Stream.of("java", "php","java");
Long sumLong = language3.collect(Collectors.summingLong(String::length));
System.out.println(sumLong);//11

Stream.sum() 实现相同功能

当Stream的类似是数字时，可以用Stream.sum()实现相同功能

DoubleStream language = DoubleStream.of(4, 3, 4);
double sumDouble = language.sum();
System.out.println(sumDouble);//11.0

IntStream language2 = IntStream.of(4, 3, 4);
Integer sumInt = language2.sum();
System.out.println(sumInt);//11

LongStream language3 = LongStream.of(4, 3, 4);
Long sumLong = language3.sum();
System.out.println(sumLong);//11

summarizingXXX

汇总统计

Collector<T, ?, DoubleSummaryStatistics> summarizingDouble(ToDoubleFunction<? super T> mapper)
以Double类型数值函数汇总统计，包含了 总数，总和，最小值，最大值，平均值 五个指标。

Collector<T, ?, IntSummaryStatistics> summarizingInt(ToIntFunction<? super T> mapper)
以Integer类型数值函数汇总统计，包含了 总数，总和，最小值，最大值，平均值 五个指标。

Collector<T, ?, LongSummaryStatistics> summarizingLong(ToLongFunction<? super T> mapper)
以Long类型数值函数汇总统计，包含了 总数，总和，最小值，最大值，平均值 五个指标。

Stream<String> language = Stream.of("java", "php","java");
DoubleSummaryStatistics doubleSummaryStatistics = language.collect(Collectors.summarizingDouble(String::length));
System.out.println(doubleSummaryStatistics);//DoubleSummaryStatistics{count=3, sum=11.000000, min=3.000000, average=3.666667, max=4.000000}

Stream<String> language2 = Stream.of("java", "php","java");
IntSummaryStatistics intSummaryStatistics = language2.collect(Collectors.summarizingInt(String::length));
System.out.println(intSummaryStatistics);//IntSummaryStatistics{count=3, sum=11, min=3, average=3.666667, max=4}

Stream<String> language3 = Stream.of("java", "php","java");
LongSummaryStatistics longSummaryStatistics = language3.collect(Collectors.summarizingLong(String::length));
System.out.println(longSummaryStatistics);//LongSummaryStatistics{count=3, sum=11, min=3, average=3.666667, max=4}

mapping

Collector<T, ?, R> mapping(Function<? super T, ? extends U> mapper, Collector<? super U, A, R> downstream)
先对元素使用 mapper 进行再加工操作，然后用另一个downstream 归纳

Stream<String> language = Stream.of("java", "php","java");
List<String> list = language.collect(Collectors.mapping(s -> s.substring(1), Collectors.toList()));
System.out.println(list);//[ava, hp, ava]

Stream.map 实现相同功能

Stream<String> language2 = Stream.of("java", "php","java");
List<String> list2 = language2.map(s -> s.substring(1)).collect(Collectors.toList());
System.out.println(list2);//[ava, hp, ava]

reducing

Collector<T, ?, Optional<T>> reducing(BinaryOperator<T> op)
根据op比较器来比较大小并分别返回最大值或者最小值,可能拿不到结果

Collector<T, ?, T> reducing(T identity, BinaryOperator<T> op)
根据op比较器来比较大小并分别返回最大值或者最小值,identity为基准值，基准值也参与比较，没有结果时返回基准值，否则返回比较结果

Collector<T, ?, U> reducing(U identity, Function<? super T, ? extends U> mapper, BinaryOperator<U> op)
先对元素进行mapper映射处理，再根据op比较器来比较大小并分别返回最大值或者最小值,identity为基准值，基准值也参与比较，没有结果时返回基准值，否则返回比较结果

Stream<String> language = Stream.of("java", "php","java");
Comparator<String> comparing = Comparator.comparing(String::length);
Optional<String> obj = language.collect(Collectors.reducing(BinaryOperator.minBy(comparing)));
System.out.println(obj);//Optional[php]

Stream<String> language2 = Stream.of("java", "php","java");
Comparator<String> comparing2 = Comparator.comparing(String::length);
String objStr = language2.collect(Collectors.reducing("androd", BinaryOperator.maxBy(comparing2)));
System.out.println(objStr);//androd

Stream<String> language3 = Stream.of("java", "php","java");
Function<String, String> mapper = str -> {return str.substring(1);};
Comparator<String> comparing3 = Comparator.comparing(String::length);
String objStr2 = language3.collect(Collectors.reducing("androd", mapper, BinaryOperator.maxBy(comparing3)));
System.out.println(objStr2);//androd

Stream.reduce 实现相同功能

Stream<String> language = Stream.of("java", "php","java");
Comparator<String> comparing = Comparator.comparing(String::length);
Optional<String> obj = language.reduce(BinaryOperator.minBy(comparing));
System.out.println(obj);//Optional[php]

Stream<String> language2 = Stream.of("java", "php","java");
Comparator<String> comparing2 = Comparator.comparing(String::length);
String objStr = language2.reduce("androd", BinaryOperator.maxBy(comparing2));
System.out.println(objStr);//androd

Stream<String> language3 = Stream.of("java", "php","java");
BiFunction<String, String, String> mapper = (str1, str2) -> { return str1.length()>str2.length()? str1:str2; };
Comparator<String> comparing3 = Comparator.comparing(String::length);
//第三个参数BinaryOperator.minBy(comparing3)无效，作用是合并各个流结果，故在parallelStream时才生效
String objStr2 = language3.reduce("androd", mapper, BinaryOperator.minBy(comparing3));
System.out.println(objStr2);//androd

averagingDouble

Collector<T, ?, Double> averagingDouble(ToDoubleFunction<? super T> mapper)
对元素进行Double类型数值函数映射处理后，求拼接值

Collector<T, ?, Double> averagingInt(ToIntFunction<? super T> mapper)
对元素进行Int类型数值函数映射处理后，求拼接值

Collector<T, ?, Double> averagingLong(ToLongFunction<? super T> mapper)
对元素进行Long类型数值函数映射处理后，求拼接值

Stream<String> language = Stream.of("java", "php","java");
Double averagingDouble = language.collect(Collectors.averagingDouble(String::length));
System.out.println(averagingDouble);//3.6666666666666665

Stream<String> language2 = Stream.of("java", "php","java");
Double averagingInt2 = language2.collect(Collectors.averagingInt(String::length));
System.out.println(averagingInt2);//3.6666666666666665

Stream<String> language3 = Stream.of("java", "php","java");
Double averagingLong3 = language3.collect(Collectors.averagingLong(String::length));
System.out.println(averagingLong3);//3.6666666666666665

Stream.average() 实现相同功能

当Stream的类似是数字时，可以用Stream.sum()实现相同功能

DoubleStream language = DoubleStream.of(4, 3, 4);
OptionalDouble sumDouble = language.average();
System.out.println(sumDouble.getAsDouble());//3.6666666666666665

IntStream language2 = IntStream.of(4, 3, 4);
OptionalDouble sumInt = language2.average();
System.out.println(sumInt.getAsDouble());//3.6666666666666665

LongStream language3 = LongStream.of(4, 3, 4);
OptionalDouble sumLong = language3.average();
System.out.println(sumLong.getAsDouble());//3.6666666666666665
借物小人
关注
专栏目录
Java 8 Stream 的终极技巧——Collectors 功能与操作方法详解
08-19
主要介绍了Java 8 Stream Collectors 功能与操作方法,结合实例形式详细分析了Java 8 Stream Collectors 功能、操作方法及相关注意事项,需要的朋友可以参考下
Java8 Stream Collectors
zym_1321的博客
06-11 251
Collectors 类实现了很多归约操作，例如将流转换成集合和聚合元素。返回列表、字符串、或产生统计结果的收集器 实例如下： static class Student { private String address; private String name; private Integer age; public Stude...
Java Collectors工具类
最新发布
weixin_47363690的博客
09-19 559
Collectors是 Java 8 引入的一个工具类，用于提供各种常见的Collector实现。这些Collector可以用于将流中的元素收集到各种目标容器中，如ListSetMap等。下面是一些Collectors工具类中常用的静态方法及其用法示例。
Java 8系列之Stream的强大工具Collector
热门推荐
行云间
02-10 5万+
概述前面我们使用过collect(toList())，在流中生成列表。实际开发过程中，List又是我们经常用到的数据结构，但是有时候我们也希望Stream能够转换生成其他的值，比如Map或者set，甚至希望定制生成想要的数据结构。collect也就是收集器，是Stream一种通用的、从流生成复杂值的结构。只要将它传给collect方法，也就是所谓的转换方法，其就会生成想要的数据结构。这里不得不提下，
Java8的 Stream 之Collectors收集器
小逹的博客
05-26 3366
Stream 的核心在于Collectors，即对处理后的数据进行收集。Collectors 提供了非常多且强大的API，可以将最终的数据收集成List、Set、Map，甚至是更复杂的结构(这三者的嵌套组合)。 Collectors 提供了很多API，有很多都是一些函数的重载，这里我个人将其分为三大类，如下： 数据收集：set、map、list 聚合归约：统计、求和、最值、平均、字符串拼接、规约 前后处理：分区、分组、自定义操作 API 使用 这里会讲到一些常用API 的用
看山聊Java：一文掌握 Java8 Stream 中 Collectors 的 24 个操作
沉潜飞动
05-13 1684
你好，我是看山。 Java8 应该算是业界主版本了，版本中重要性很高的一个更新是Stream流处理。关于流处理内容比较多，本文主要是说一下Stream中的Collectors工具类的使用。 Collectors是java.util.stream包下的一个工具类，其中各个方法的返回值可以作为java.util.stream.Stream#collect的入参，实现对队列的各种操作，包括：分组、聚合等。官方文档给出一些例子： Implementations of {@link Collector} tha.
Java 8 Stream API 的 Collectors 类深度解析
09-15
在 Java 8 引入的 Stream API 中，java.util.stream.Collectors 类扮演着至关重要的角色。它提供了一种高级的方式来处理集合数据，使得数据聚合和转换操作变得简单而高效。本文将深入探讨 Collectors 类的作用、常用...
Java中的`java.util.stream.Collectors.toMap()`方法有什么作用
09-15
Collectors.toMap()是Java 8 Stream API中一个非常实用的工具，它简化了将流中的元素收集到Map中的过程。通过本文的介绍，你应该能够理解Collectors.toMap()的工作原理，并能够在实际开发中灵活运用它。如果你有任何...
javastream源码-demo-java-stream-collectors:“预定义的Java流收集器”文章和源代码
05-19
stream源码预定义的Java流收集器 介绍 有几种方法可以将Stream作为一系列输入元素简化为一个汇总结果。 其中之一是使用接口与方法的实现。 可以显式实现此接口，但是它应该从类中研究其预定义的实现开始。 预定义...
深入探讨 Java 8 Stream API 的 Collectors.minBy() 方法
09-15
在 Java 8 引入的 Stream API 中，java.util.stream.Collectors.minBy() 方法是一个强大的工具，用于在集合操作中找到流中按照指定比较器最小的元素。与 maxBy() 方法相对应，minBy() 提供了一种声明式的方式来确定...
Java Stream API进阶篇
weixin_30633405的博客
03-15 170
本文github地址 上一节介绍了部分Stream常见接口方法，理解起来并不困难，但Stream的用法不止于此，本节我们将仍然以Stream为例，介绍流的规约操作。 规约操作（reduction operation）又被称作折叠操作（fold），是通过某个连接动作将所有元素汇总成一个汇总结果的过程。元素求和、求最大值或最小值、求出元素总个数、将所有元素转换成一个列表或集合，都属于规约操作。Stre...
java stream 之Collector
qq_26471769的博客
03-24 1456
lambda,collector.of()
java8之stream流之Collector和Collectors
无区新手的博客
11-09 2364
Collector Collector是专门用来作为Stream的collect方法的参数的。 public interface Stream<T> extends BaseStream<T, Stream<T>> { <R, A> R collect(Collector<? super T, A, R> collector); } 而Collectors是作为生产具体Collector的工具类。 Collector主要包含五个.
js 中转换成list集合_java stream中Collectors的用法
weixin_30362743的博客
12-26 883
简介在java stream中，我们通常需要将处理后的stream转换成集合类，这个时候就需要用到stream.collect方法。collect方法需要传入一个Collector类型，要实现Collector还是很麻烦的，需要实现好几个接口。于是java提供了更简单的Collectors工具类来方便我们构建Collector。下面我们将会具体讲解Collectors的用法。假如我们有这样两个li...
Java8的流Stream与收集器Collector详解
zw19910924的专栏
08-08 1万+
流Stream概述Stream可以说是java8的一大亮点。java8中的Stream对集合功能进行了增强。在日常开发中，我们免不了要经常对集合对象进行处理，而在java8以前，对于集合的处理完全是由我们自己来操作，所以代码看起来相对繁杂。而有了Stream以后，对于集合的处理得到了大大的简化。Stream提供了对集合对象的各种非常便利的、高效的聚合操作。集合和Stream，表面看起来很相似，却有着
java8 lambda中stream、collectors
hao_hl1314的博客
05-23 689
使用map加reduce操作符实现 List&lt;String&gt; list=Arrays.asList(new String[]{"1.0","3","2","5.2","4"}); Double total=list.stream().map(BigDecimal::new).reduce((sum,item)-&gt;sum.add(item)).map(BigDeci
java8stream中Collectors常用方法介绍
qq_44462054的博客
04-13 1846
stream
Java8 Stream Collectors 使用
湖人•总冠军
03-13 6804
前言： java.util.stream.Collectors.* 类为我们提供了丰富的对流的操作,对此写了一些较为测试案例： import java.text.DecimalFormat; import java.util.*; import java.util.concurrent.ConcurrentMap; import static java.util.Compara...
java stream Collectors
Claroja
03-01 87
实现了Interface Collector提供了存放元素的容易 Collectors.toList() Collectors.toSet() Collectors.toMap Collectors.toCollection(TreeSet::new) Collectors.groupingBy() 其他的方法和Stream有重叠不建议使用
Java8 Stream FlatMap 深入理解与应用示例
"本文主要探讨了Java 8 Stream API中的flatMap操作，它是处理集合数据时的一种强大工具，尤其在扁平化多层结构方面表现出色。通过实例代码，阐述了flatMap的基本用法和其在中间操作与终端操作中的角色。" 在Java 8...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值