Collectors 中的各种方法

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

Collectors 中提供了很多好用的 Collector 实现，大大提高了我们的生产力，比如，将元素放入 Collection，一些聚合、汇总、分组操作。

转集合：toCollection、toList、toSet

  • toCollection() 可以转成任意的 Collection 实现类
  • toList 转成 ArrayList
  • toSet 转成 HashSet
public static void main(String[] args) {
    String[] arr = {"a", "b", "c", "d"};
    toCollection(arr);
}

public static void toCollection(String[] arr) {
    ArrayList<String> list1 = Arrays.stream(arr).collect(Collectors.toCollection(ArrayList::new));
    System.out.println(list1);

    List<String> list2 = Arrays.stream(arr).collect(Collectors.toList());
    System.out.println(list2);

    Set<String> set = Arrays.stream(arr).collect(Collectors.toSet());
    System.out.println(set);
}

[a, b, c, d]
[a, b, c, d]
[a, b, c, d][a, b, c, d]

转Map：toMap、toConcurrentMap

toMap

// 创建 HashMap，有重复 key 时抛异常 java.lang.IllegalStateException: Duplicate key
public static <T, K, U>
    Collector<T, ?, Map<K,U>> toMap(Function<? super T, ? extends K> keyMapper,
                                    Function<? super T, ? extends U> valueMapper);

// 在上面的基础上，当出现 key 重复时，自定义对 value 的处理策略，（阿里手册强制使用）。
public static <T, K, U>
    Collector<T, ?, Map<K,U>> toMap(Function<? super T, ? extends K> keyMapper,
                                    Function<? super T, ? extends U> valueMapper,
                                    BinaryOperator<U> mergeFunction)

// 在上面的基础上，可以自由控制 Map 的类型
public static <T, K, U, M extends Map<K, U>>
    Collector<T, ?, M> toMap(Function<? super T, ? extends K> keyMapper,
                             Function<? super T, ? extends U> valueMapper,
                             BinaryOperator<U> mergeFunction,
                             Supplier<M> mapSupplier)

@Data
private static class Person {
    private String name;

    private String address;

    public Person(String name, String address) {
        this.name = name;
        this.address = address;
    }

    public static Person of(String name, String address) {
        return new Person(name, address);
    }
}

public static void toMap(List<Person> list) {
    Map<String, String> map1 = list.stream().collect(Collectors.toMap(
            Person::getName, Person::getAddress, (v1, v2) -> v1 + " " + v2, TreeMap::new));

    Map<String, String> map2 = list.stream().collect(Collectors.toMap(
            Person::getName, Person::getAddress, (v1, v2) -> v1 + " " + v2));

    System.out.println(map1.getClass() + " - " + map1);
    System.out.println(map2.getClass() + " - " + map2);

    Map<String, String> map3 = list.stream().collect(Collectors.toMap(
            Person::getName, Person::getAddress));
    System.out.println(map3.getClass() + " - " + map3);
}

没有重复 key

public static void main(String[] args) {
    List<Person> list = new ArrayList<>();
    list.add(Person.of("张三", "北京"));
    list.add(Person.of("李四", "上海"));
    list.add(Person.of("王五", "深圳"));
    toMap(list);
}

class java.util.TreeMap - {张三=北京, 李四=上海, 王五=深圳}
class java.util.HashMap - {李四=上海, 张三=北京, 王五=深圳}
class java.util.HashMap - {李四=上海, 张三=北京, 王五=深圳}

存在重复 key

public static void main(String[] args) {
    List<Person> list = new ArrayList<>();
    list.add(Person.of("张三", "北京"));
    list.add(Person.of("李四", "上海"));
    list.add(Person.of("李四", "深圳"));
    toMap(list);
}

class java.util.TreeMap - {张三=北京, 李四=上海 深圳}
class java.util.HashMap - {李四=上海 深圳, 张三=北京}
Exception in thread "main" java.lang.IllegalStateException: Duplicate key 上海
	at java.util.stream.Collectors.lambda$throwingMerger$0(Collectors.java:133)
	at java.util.HashMap.merge(HashMap.java:1254)
	at java.util.stream.Collectors.lambda$toMap$58(Collectors.java:1320)
	at java.util.stream.ReduceOps$3ReducingSink.accept(ReduceOps.java:169)
	at java.util.ArrayList$ArrayListSpliterator.forEachRemaining(ArrayList.java:1384)
	at java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:482)
	at java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:472)
	at java.util.stream.ReduceOps$ReduceOp.evaluateSequential(ReduceOps.java:708)
	at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:234)
	at java.util.stream.ReferencePipeline.collect(ReferencePipeline.java:499)
	at com.example.heima.collectors.ToMap1.toMap(ToMap1.java:39)
	at com.example.heima.collectors.ToMap1.main(ToMap1.java:26)

toConcurrentMap

有 toMap 的几个方法相似，但会创建 ConcurrentMap


public static <T, K, U>
	Collector<T, ?, ConcurrentMap<K,U>> toConcurrentMap(Function<? super T, ? extends K> keyMapper,
                                                    Function<? super T, ? extends U> valueMapper) 

public static <T, K, U>
	Collector<T, ?, ConcurrentMap<K,U>> toConcurrentMap(Function<? super T, ? extends K> keyMapper,
                									Function<? super T, ? extends U> valueMapper,
                									BinaryOperator<U> mergeFunction)

public static <T, K, U, M extends ConcurrentMap<K, U>>
	Collector<T, ?, M> toConcurrentMap(Function<? super T, ? extends K> keyMapper,
                                       Function<? super T, ? extends U> valueMapper,
                                       BinaryOperator<U> mergeFunction,
                                       Supplier<M> mapSupplier)

字符串拼接：joining

// 直接拼接，没有分隔符
public static Collector<CharSequence, ?, String> joining()

// 指定分隔符
public static Collector<CharSequence, ?, String> joining(CharSequence delimiter)

// 指定分隔符、前缀、后缀
public static Collector<CharSequence, ?, String> joining(CharSequence delimiter,
                                                         CharSequence prefix,
                                                         CharSequence suffix)

public static void main(String[] args) {
    String[] arr = {"a", "b", "c", "d"};
    List<String> list = Arrays.asList(arr);

    String s1 = list.stream().collect(Collectors.joining());
    String s2 = list.stream().collect(Collectors.joining(","));
    String s3 = list.stream().collect(Collectors.joining(",", "[", "]"));

    System.out.println(s1);
    System.out.println(s2);
    System.out.println(s3);
}

abcd
a,b,c,d
[a,b,c,d]

适配器：mapping

// 先执行一个 mapper，将T 映射成 U，再执行另一个 Collector
public static <T, U, A, R>
Collector<T, ?, R> mapping(Function<? super T, ? extends U> mapper,
                           Collector<? super U, A, R> downstream)

public static void main(String[] args) {
    String[] arr = {"a", "ab", "abc"};

    List<Integer> list = Arrays.stream(arr).collect(
            Collectors.mapping(String::length, Collectors.toList()));

    System.out.println(list);
}

[1, 2, 3]

先归纳再处理：collectingAndThen

// 先执行 downstream，然后将 downstream 的返回值 R 转为 RR 类型
public static<T,A,R,RR> Collector<T,A,RR> collectingAndThen(Collector<T,A,R> downstream,
                                                            Function<R,RR> finisher)

// 先转 Set，再取 size
public static void main(String[] args) {
    String[] arr = {"a", "b", "c", "d", "a", "b"};
    
    int size = Arrays.stream(arr).collect(
        	Collectors.collectingAndThen(Collectors.toSet(), Set::size));

    System.out.println(size);
}

4

聚合操作

计数：counting

public static void main(String[] args) {
    String[] arr = {"a", "b", "c", "d"};
    Long count = Arrays.stream(arr).collect(Collectors.counting());
    System.out.println(count);
}

4

最大最小值：maxBy、minBy

public static void main(String[] args) {
    List<Person> list = new ArrayList<>();
    list.add(Person.of("张三", 18));
    list.add(Person.of("李四", 25));
    list.add(Person.of("王五", 15));

    Optional<Person> min = list.stream().collect(
        	Collectors.minBy(Comparator.comparingInt(Person::getAge)));
    Optional<Person> max = list.stream().collect(
        	Collectors.maxBy(Comparator.comparingInt(Person::getAge)));
    
    System.out.println(min);
    System.out.println(max);
}

@Data
@AllArgsConstructor
private static class Person {
    private String name;

    private int age;

    public static Person of(String name, int age) {
        return new Person(name, age);
    }
}

Optional[MinMax.Person(name=王五, age=15)]
Optional[MinMax.Person(name=李四, age=25)]

求和：summingInt、summingLong、summingDouble

public static void main(String[] args) {
    List<Person> list = new ArrayList<>();
    list.add(Person.of("张三", 18));
    list.add(Person.of("李四", 25));
    list.add(Person.of("王五", 15));

    Integer ageSum = list.stream().collect(Collectors.summingInt(Person::getAge));
    Integer lengthSum = list.stream().collect(Collectors.summingInt((p) -> p.getName().length()));

    System.out.println(ageSum);
    System.out.println(lengthSum);
}


@Data
@AllArgsConstructor
private static class Person {
    private String name;

    private int age;

    public static Person of(String name, int age) {
        return new Person(name, age);
    }
}

58
6

平均数：averagingInt、averagingLong、averagingDouble

public static void main(String[] args) {
    List<Person> list = new ArrayList<>();
    list.add(Person.of("张三", 18));
    list.add(Person.of("李四", 25));
    list.add(Person.of("王五", 15));

    Double ageAvg = list.stream().collect(Collectors.averagingInt(Person::getAge));
    Double lengAvg = list.stream().collect(Collectors.averagingInt((p) -> p.getName().length()));

    System.out.println(ageAvg);
    System.out.println(lengAvg);
}


@Data
@AllArgsConstructor
private static class Person {
    private String name;

    private int age;

    public static Person of(String name, int age) {
        return new Person(name, age);
    }
}

19.333333333333332
2.0

reducing

BinaryOperator 是一个二元的函数，BinaryOperator<T> extends BiFunction<T,T,T>，输入两个参数，返回一个结果，且参数和返回值都是相同类型的 。

reducing()返回的 Collector 会利用 BinaryOperator 进行元素的 reduce 操作，即 (T, T) -> T。

// 利用 op 对元素执行 reduce 操作，返回值为 Optional<T>
public static <T> Collector<T, ?, Optional<T>> reducing(BinaryOperator<T> op)

// 在上面的基础上添加了初始值 identity，
public static <T> Collector<T, ?, T> reducing(T identity, BinaryOperator<T> op)

// 在上面的基础上添加了 mapper 函数，可将输入的元素从类型 T 转换成 U，再进行 reduce 操作
public static <T, U> Collector<T, ?, U> reducing(U identity,
                                				 Function<? super T, ? extends U> mapper,
                                				 BinaryOperator<U> op)
实现 minBy、maxBy 功能
public static void main(String[] args) {
    List<Person> list = new ArrayList<>();
    list.add(Person.of("张三", 18));
    list.add(Person.of("李四", 25));
    list.add(Person.of("王五", 15));

    Optional<Person> min = list.stream().collect(
        	Collectors.reducing(BinaryOperator.minBy(Comparator.comparingInt(Person::getAge))));
    Optional<Person> max = list.stream().collect(
        	Collectors.reducing(BinaryOperator.maxBy(Comparator.comparingInt(Person::getAge))));

    System.out.println(min);
    System.out.println(max);
}


@Data
@AllArgsConstructor
private static class Person {
    private String name;

    private int age;

    public static Person of(String name, int age) {
        return new Person(name, age);
    }
}

Optional[Reducing1.Person(name=王五, age=15)]
Optional[Reducing1.Person(name=李四, age=25)]
实现 counting 功能
public static void main(String[] args) {
    String[] arr = {"a", "b", "c", "d"};
    Long count = Arrays.stream(arr).collect(Collectors.reducing(0L, e -> 1L, Long::sum));
    System.out.println(count);
}

4
按 city 分组，每个城市的最高身高
public static void main(String[] args) {
    List<Person> list = new ArrayList<>();
    list.add(Person.of("北京", 160));
    list.add(Person.of("北京", 181));
    list.add(Person.of("上海", 179));
    list.add(Person.of("上海", 171));
    list.add(Person.of("深圳", 190));
    list.add(Person.of("深圳", 166));

    Map<String, Integer> map = list.stream().collect(Collectors.groupingBy(Person::getCity, 
            Collectors.reducing(0, Person::getHeight,
                BinaryOperator.maxBy(Comparator.comparing(Function.identity())))));

    System.out.println(map);
}

@Data
@AllArgsConstructor
private static class Person {

    private String city;

    private int height;

    public static Person of(String city, int height) {
        return new Person(city, height);
    }
}

{上海=179, 深圳=190, 北京=181}

分组：groupingBy、groupingByConcurrent

groupingBy

// 按照 classifier 的返回值进行分组，默认创建 HashMap，key 为 classifier 的返回值，value 为输入元素的 List
public static <T, K> Collector<T, ?, Map<K, List<T>>> groupingBy(
    										Function<? super T, ? extends K> classifier)

// 上面的基础上，Map 的 value 类型由 downstream 指定，比如 Collectors.toSet()
public static <T, K, A, D>
	Collector<T, ?, Map<K, D>> groupingBy(Function<? super T, ? extends K> classifier,
                                      	  Collector<? super T, A, D> downstream) 

// 在上面的基础上，有 mapFactory 创建 Map，比如 TreeMap::new
public static <T, K, D, A, M extends Map<K, D>>
	Collector<T, ?, M> groupingBy(Function<? super T, ? extends K> classifier,
                              	  Supplier<M> mapFactory,
                              	  Collector<? super T, A, D> downstream)

public static void main(String[] args) {
    List<Person> list = new ArrayList<>();
    list.add(Person.of("北京", "张三"));
    list.add(Person.of("上海", "李四"));
    list.add(Person.of("深圳", "王五"));
    list.add(Person.of("北京", "小明"));
    list.add(Person.of("深圳", "小红"));

    groupingBy(list);
}

public static void groupingBy(List<Person> list) {
    Map<String, List<Person>> map1 = list.stream().collect(
        	Collectors.groupingBy(Person::getCity));

    Map<String, Set<Person>> map2 = list.stream().collect(
        	Collectors.groupingBy(Person::getCity, Collectors.toSet()));

    TreeMap<String, Set<Person>> map3 = list.stream().collect(
        	Collectors.groupingBy(Person::getCity, TreeMap::new, Collectors.toSet()));

    TreeMap<String, Set<String>> map4 = list.stream().collect(
        	Collectors.groupingBy(Person::getCity, TreeMap::new, 
                                  Collectors.mapping(Person::getName, Collectors.toSet())));

    System.out.println(map1.getClass() + " - " + map1);
    System.out.println(map2.getClass() + " - " + map2);
    System.out.println(map3.getClass() + " - " + map3);
    System.out.println(map4.getClass() + " - " + map4);
}


@Data
@AllArgsConstructor
private static class Person {
    private String city;

    private String name;

    public static Person of(String city, String name) {
        return new Person(city, name);
    }
    
    @Override
    public String toString() {
        return city + "<=" + name;
    }
}

class java.util.HashMap - {上海=[上海<=李四], 深圳=[深圳<=王五, 深圳<=小红], 北京=[北京<=张三, 北京<=小明]}
class java.util.HashMap - {上海=[上海<=李四], 深圳=[深圳<=小红, 深圳<=王五], 北京=[北京<=小明, 北京<=张三]}
class java.util.TreeMap - {上海=[上海<=李四], 北京=[北京<=小明, 北京<=张三], 深圳=[深圳<=小红, 深圳<=王五]}
class java.util.TreeMap - {上海=[李四], 北京=[张三, 小明], 深圳=[王五, 小红]}

groupingByConcurrent

与 groupingBy 功能类似，但返回 ConcurrentMap

public static <T, K> Collector<T, ?, ConcurrentMap<K, List<T>>>
    groupingByConcurrent(Function<? super T, ? extends K> classifier) 
    
public static <T, K, A, D>
    Collector<T, ?, ConcurrentMap<K, D>> groupingByConcurrent(
    										Function<? super T, ? extends K> classifier,
                                            Collector<? super T, A, D> downstream)
                                                              
public static <T, K, A, D, M extends ConcurrentMap<K, D>>
    Collector<T, ?, M> groupingByConcurrent(Function<? super T, ? extends K> classifier,
                                            Supplier<M> mapFactory,
                                            Collector<? super T, A, D> downstream)

分区：partitioningBy

只会分成 TRUE、FALSE 两个区

// 根据 predicate 进行分区，返回值为 Map<Boolean, List<T>>
public static <T>
    Collector<T, ?, Map<Boolean, List<T>>> partitioningBy(Predicate<? super T> predicate)

// 根据 predicate 进行分区，返回值为 Map<Boolean, D>，D 是 downstream 的返回值
public static <T, D, A>
    Collector<T, ?, Map<Boolean, D>> partitioningBy(Predicate<? super T> predicate,
                                                    Collector<? super T, A, D> downstream)

public static void main(String[] args) {
    String[] arr = {"a", "bb", "ccc", "dddd", "eeeee"};
    Map<Boolean, List<String>> map1 = Arrays.stream(arr).collect(
        	Collectors.partitioningBy(e -> e.length() > 2));

    Map<Boolean, Set<String>> map2 = Arrays.stream(arr).collect(
        	Collectors.partitioningBy(e -> e.length() > 2, Collectors.toSet()));

    System.out.println(map1);
    System.out.println(map2);
}

{false=[a, bb], true=[ccc, dddd, eeeee]}
{false=[bb, a], true=[ccc, eeeee, dddd]}

统计信息：summarizingInt、summarizingLong、summarizingDouble

返回的统计信息包括：sum、count、average、min、max

public static void main(String[] args) {
    List<Person> list = new ArrayList<>();
    list.add(Person.of("张三", 18));
    list.add(Person.of("李四", 25));
    list.add(Person.of("王五", 15));

    IntSummaryStatistics statistics = list.stream().collect(Collectors.summarizingInt(Person::getAge));

    System.out.println(statistics);
}


@Data
@AllArgsConstructor
private static class Person {
    private String name;

    private int age;

    public static Person of(String name, int age) {
        return new Person(name, age);
    }
}

IntSummaryStatistics{count=3, sum=58, min=15, average=19.333333, max=25}

参考

赵丙双
关注
  • 2
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java 8 Stream 的终极技巧——Collectors 功能与操作方法详解
08-19
主要介绍了Java 8 Stream Collectors 功能与操作方法,结合实例形式详细分析了Java 8 Stream Collectors 功能、操作方法及相关注意事项,需要的朋友可以参考下
Collectors常用方法
Mr. Wu's blog
04-19 414
/** * @author W * @date 2022/4/18 */ public class StreamTest { /** * 返回List集合 * toList */ @Test public void stream1(){ List<Integer> integers = Arrays.asList(1,2,3,4,5,6,6); System.out.println(integers);.
一文掌握 Java8 Stream 中 Collectors 的 24 个操作
最新发布
2401_84815456的博客
05-09 877
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
Java8、Collectors方法大全
雨后是冰雹
03-23 1079
Collectors方法大全一、所用示例类1. Student2. GradeType3. CollectorsTest二、Collectors方法及使用1. Collectors.toCollection()2. Collectors.toList() / Collectors.toSet()3. Collectors.toMap(Function, Function) / Collectors.toConcurrentMap(Function, Function)4. Collectors.to
java流式编程（七）Collectors中的常用方法
码易的博客
02-28 2702
目录前言一、创建实体类二、测试数据二、测试方法1、toCollection(Supplier collectionFactory)2、toList()3、toSet()4、toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper)5、toMap(Function<? super T, ? extends K> keyMapper, Fu..
[四] java8 函数式编程 收集器浅析 收集器Collector常用方法 运行原理 内部实现
noteless的博客
08-21 215
Collector常见用法     常用形式为:   .collect(Collectors.toList()) collect()是Stream的方法 Collectors  是收集器Collector 的工厂方法,提供了一些常用的收集器  比如   常用收集器概要 收集器 行为 toList() 将元素收集到一个  List...
Java8 Stream Collectors收集器使用方法解析
08-18
Java8 Stream Collectors收集器是Java8中Stream API的一种重要组件， Collectors是 Stream API 中的收集器接口，提供了许多实用的方法来处理Stream流数据。以下是Java8 Stream Collectors收集器使用方法解析的详细...
Collectors_v1
04-08
在Java编程中，`Collectors`是Java 8引入的一个重要工具类，它位于`java.util.stream.Collectors`包下，极大地丰富了Stream API的功能，为数据收集提供了各种实用方法。`Collectors_v1`可能是某个项目或者教程中关于...
JDK12的新特性之teeing collectors
08-19
JDK12中引入了一个新的特性叫做teeing collectors，它是java.util.stream.Collectors添加的一个新的方法。teeing collectors的主要作用是将数据从两头输入，然后从一头输出，类似于T型结构。 在JDK12中，Collectors...
Java9 Stream Collectors新增功能(小结)
08-25
Stream 的 filter() 方法是在 stream 链接方法中使用的，而 Collectors.filtering 方法被设计和 groupingBy 一起使用。Stream 的 filter() 方法首先过滤元素，然后再分组。被过滤的值被丢弃无法被追溯跟踪。如果需要...
java8 Collectors 常用方法
月眸
12-23 2122
Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。 Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。 Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。 这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理...
Collectors常见操作
YM550的博客
09-13 821
1.Collector主要包含五个参数的意义 public interface Collector<T, A, R> { // supplier参数用于生成结果容器，容器类型为A Supplier<A> supplier(); // accumulator用于消费元素，也就是归纳元素，这里的T就是元素，它会将流中的元素一个一个与结果容器A发生操作 BiConsumer<A, T> accumulator(); // combin
Java8 -- 05 -- Collectors类常用方法解析
Gene Xu
06-20 1358
在使用流之前，我们先来了解下 Collectors 类，因为在使用流的过程中，会经常用到该类的相关方法 Collectors 工具类提供了许多静态工具方法来创建收集器，比如将元素装进一个集合中、将元素分组、根据不同标准对元素进行汇总等，现在我们就来看看它具体使用 Student.java public class Student { private String name; private int age; private double score; public
Java-Collectors常用的20个方法
郑龙飞
11-15 2898
相思相见知何日？此时此夜难为情。 返回List集合: toList() 用于将元素累积到List集合中。它将创建一个新List集合（不会更改当前集合）。 List<Integer> integers = Arrays.asList(1,2,3,4,5,6,6); integers.stream().map(x -> x*x).collect(Collectors.toList()); // output: [1,4,9,16,25,36,36] 返回Set集合: toSet() 用.
java8stream中Collectors常用方法介绍
qq_44462054的博客
04-13 1513
stream
js 中转换成list集合_java stream中Collectors的用法
weixin_30362743的博客
12-26 807
简介在java stream中，我们通常需要将处理后的stream转换成集合类，这个时候就需要用到stream.collect方法。collect方法需要传入一个Collector类型，要实现Collector还是很麻烦的，需要实现好几个接口。于是java提供了更简单的Collectors工具类来方便我们构建Collector。下面我们将会具体讲解Collectors的用法。假如我们有这样两个li...
Collectors使用
weixin_34352005的博客
11-11 91
2019独角兽企业重金招聘Python工程师标准>>> ...
Collector原理解析
qq_44918331的博客
07-20 651
collect函数式编程原理解析
【Stream API笔记02】JDK1.8新特性之Stream API中Collectors类相关方法的使用
10-03 465
Collectors类，是JDK1.8开始提供的一个的工具类，它专门用于对Stream流中的元素各种处理操作，Collectors类中提供了一些常用的方法，例如：toList()、toSet()、toCollection()、toMap()、toConcurrentMap()方法，以及一些分组聚合的方法。
Collectors reducing 使用方法
07-13
Collectors是Java 8引入的一个用于对流...这只是Collectors的一小部分用法示例，你可以根据具体需求使用不同的Collectors方法来实现不同的操作。希望能对你有所帮助！如果你有更具体的问题，可以提出来让我帮你解答。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值