Java8 Collectors类详解(一)

这篇具有很好参考价值的文章主要介绍了Java8 Collectors类详解(一)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

  Collectors 类是用于对流进行收集和汇总的工具类。它提供了许多方法来对流进行分组、统计、转换、分区、连接、归约等操作,使得处理集合类数据变得更加方便。

        在使用 Collectors 类时,我们可以通过调用其中的方法来实现对流的不同处理方式。例如,将流中的元素收集到一个 List 中,可以使用 toList() 方法;按照指定条件进行分组,可以使用 groupingBy() 方法;统计流中的元素个数,可以使用 counting() 方法等等。

        此外,Collectors 类还支持自定义收集器,即我们可以根据自己的需求来编写实现了 Collector 接口的自定义收集器,然后直接在代码中使用。这个功能在一些复杂的应用场景下非常有用。

转换

toList()

  Collectors.toList() 方法是 Java 中 Collectors 类提供的一个用于将流中的元素收集到一个 List 集合中的方法。

List<Integer> list = Stream.of(1, 2, 3, 4, 5)
    .collect(Collectors.toList());

在上面的示例中,我们创建了一个包含 1~5 的整数流,并使用 collect 方法配合 Collectors.toList() 方法将流中的元素收集到一个 List 集合中。最终得到的 list 集合中包含了流中所有的元素,即 {1, 2, 3, 4, 5}

需要注意的是,Collectors.toList() 方法返回的是一个不可变的 List 集合,因此不能对其进行增删操作,但是其中的元素可以修改。如果我们需要获取一个可修改的 List 集合,可以将其转换为 ArrayList

List<Integer> list = Stream.of(1, 2, 3, 4, 5)
    .collect(Collectors.toCollection(ArrayList::new));

上述代码中,我们使用 Collectors.toCollection() 方法,并指定要创建的集合类型为 ArrayList,这样就能够得到一个可修改的 List 集合了。

总之,Collectors.toList() 方法在实际开发中非常常用,它可以方便地将流中的元素收集到一个 List 集合中,进一步满足我们对数据的处理需求。

toSet()

Collectors.toSet() 方法是 Java 中 Collectors 类提供的一个用于将流中的元素收集到一个 Set 集合中的方法。

Set<Integer> set = Stream.of(1, 2, 3, 4, 5)
    .collect(Collectors.toSet());

在上面的示例中,我们创建了一个包含 1~5 的整数流,并使用 collect 方法配合 Collectors.toSet() 方法将流中的元素收集到一个 Set 集合中。最终得到的 set 集合中包含了流中所有的元素,即 {1, 2, 3, 4, 5}

需要注意的是,Collectors.toSet() 方法返回的是一个不可变的 Set 集合,因此不能对其进行增删操作,但是其中的元素可以修改。如果我们需要获取一个可修改的 Set 集合,可以将其转换为 HashSet

Set<Integer> set = Stream.of(1, 2, 3, 4, 5)
    .collect(Collectors.toCollection(HashSet::new));

上述代码中,我们使用 Collectors.toCollection() 方法,并指定要创建的集合类型为 HashSet,这样就能够得到一个可修改的 Set 集合了。

Collectors.toSet() 方法在实际开发中非常常用,它可以方便地将流中的元素收集到一个 Set 集合中,进一步满足我们对数据的处理需求。

toCollection(Supplier<C> collectionFactory)

Collectors.toCollection(Supplier<C> collectionFactory) 方法是 Java 中 Collectors 类提供的一个用于将流中的元素收集到指定类型的集合中的方法。

该方法接受一个参数,即一个类型为 Supplier<C> 的函数式接口,其中 C 是要创建的集合类型。例如,如果我们想要创建一个 LinkedList 集合,可以这样使用该方法:

List<Integer> list = Stream.of(1, 2, 3, 4, 5)
    .collect(Collectors.toCollection(LinkedList::new));

 在上述示例中,我们使用 Collectors.toCollection() 方法,并传入一个 LinkedList::new 函数,表示创建一个 LinkedList 类型的集合。最终得到的 list 集合中包含了流中所有的元素,即 {1, 2, 3, 4, 5}

需要注意的是,Collectors.toCollection() 方法返回的是一个可修改的集合,因此可以对其进行增删操作。

总之,Collectors.toCollection() 方法在实际开发中非常常用,它可以方便地将流中的元素收集到指定类型的集合中,进一步满足我们对数据的处理需求。同时,该方法还非常灵活,可以根据实际需要传入不同类型的集合工厂来创建不同类型的集合。

toConcurrentMap

Collectors.toConcurrentMap() 方法是 Java 中 Collectors 类提供的一个用于将流中的元素收集到一个并发 Map 中的方法。它有多个重载形式,其中最简单的形式不需要传入 Map 的实现类型:

ConcurrentMap<Integer, String> concurrentMap = Stream.of("a", "b", "c")
    .collect(Collectors.toConcurrentMap(
        String::length,
        Function.identity()
    ));

在上面的例子中,我们使用 toConcurrentMap() 方法创建了一个并发 Map,它将字符串的长度作为键,字符串本身作为值。具体来说,这个方法接受两个参数:

  • 一个函数式接口 keyMapper,表示如何将流中的元素转换成键;
  • 一个函数式接口 valueMapper,表示如何将流中的元素转换成值。

对于上述例子中的流,String::length 函数式接口将字符串转换成它的长度,而 Function.identity() 函数式接口则将字符串映射成它本身。因此得到的结果为:

{1=a, 2=b, 3=c}

 需要注意的是,当流中存在重复的键时,toConcurrentMap() 方法将会抛出一个 IllegalStateException 异常。我们可以通过第三个参数指定如何解决重复键的问题。例如,如果我们希望将重复的键对应的值合并成一个字符串,可以这样使用该方法:

ConcurrentMap<Integer, String> concurrentMap = Stream.of("aa", "bbb", "cc")
    .collect(Collectors.toConcurrentMap(
        String::length,
        Function.identity(),
        (s1, s2) -> s1 + "|" + s2
    ));

 在上述例子中,我们传入了一个合并函数 (s1, s2) -> s1 + "|" + s2,如果出现重复的键,则将对应的值进行合并,以 | 分隔。因此得到的结果为:

{2=aa|cc, 3=bbb}

Collectors.toConcurrentMap() 方法在实际开发中非常常用,它可以方便地将流中的元素收集到一个并发 Map 中,并且提供了丰富的方式来处理重复键等问题。

toMap

Collectors.toMap() 方法是 一个用于将流中的元素收集到一个 Map 中的方法。它有多个重载形式,其中最简单的形式不需要传入 Map 的实现类型:

Map<Integer, String> map = Stream.of("a", "b", "c")
    .collect(Collectors.toMap(
        String::length,
        Function.identity()
    ));

在上面的例子中,我们使用 toMap() 方法创建了一个 Map,它将字符串的长度作为键,字符串本身作为值。具体来说,这个方法接受两个参数:

  • 一个函数式接口 keyMapper,表示如何将流中的元素转换成键;
  • 一个函数式接口 valueMapper,表示如何将流中的元素转换成值。

对于上述例子中的流,String::length 函数式接口将字符串转换成它的长度,而 Function.identity() 函数式接口则将字符串映射成它本身。因此得到的结果为:

{1=a, 2=b, 3=c}

 需要注意的是,当流中存在重复的键时,toMap() 方法将会抛出一个 IllegalStateException 异常。我们可以通过第三个参数指定如何解决重复键的问题。例如,如果我们希望将重复的键对应的值合并成一个字符串,可以这样使用该方法:

Map<Integer, String> map = Stream.of("aa", "bbb", "cc")
    .collect(Collectors.toMap(
        String::length,
        Function.identity(),
        (s1, s2) -> s1 + "|" + s2
    ));

在上述例子中,我们传入了一个合并函数 (s1, s2) -> s1 + "|" + s2,如果出现重复的键,则将对应的值进行合并,以 | 分隔。因此得到的结果为:

{2=aa|cc, 3=bbb}

Collectors.toMap() 方法在实际开发中非常常用,它可以方便地将流中的元素收集到一个 Map 中,并且提供了丰富的方式来处理重复键等问题。

分组

groupingBy(Function<? super T, ? extends K> classifier)

Collectors.groupingBy() 方法是 Java 中 Collectors 类提供的一个用于将流中的元素按照指定的分类器分组的方法。具体来说,该方法接受一个参数:

  • 一个函数式接口 classifier,表示如何对流中的元素进行分类。

该方法有两个重载形式,其中最简单的形式只需要传入一个分类器函数:

Map<K, List<T>> map = stream.collect(Collectors.groupingBy(classifier));

其中,

  • stream 是待处理的流;
  • classifier 是一个函数式接口,用于将流中的每个元素映射为一个分类键 K

例如,我们有一个字符串列表,并希望按照字符串长度分组:

List<String> list = Arrays.asList("apple", "banana", "cherry", "date", "elderberry");
Map<Integer, List<String>> map = list.stream().collect(Collectors.groupingBy(String::length));

 在上面的代码中,我们使用 String::length 函数式接口将字符串转换为它的长度,并将其作为分类键。运行结果如下:

{3=[date], 5=[apple, cherry], 6=[banana], 10=[elderberry]}

需要注意的是,groupingBy() 方法返回的是一个 Map 对象,其中键是分类键,值则是由该分类键对应的元素构成的列表。在上述例子中,长度为 5 的字符串有两个,因此它们都被加入了同一个列表中。

除了上述方法,Collectors.groupingBy() 方法还提供了第二个参数 downstream,用于进一步对分组的结果进行处理。例如,我们可以使用 Collectors.counting() 方法统计每个分组中元素的数量:

Map<Integer, Long> map = list.stream()
    .collect(Collectors.groupingBy(String::length, Collectors.counting()));

上面的代码中,我们使用 Collectors.counting() 方法作为 downstream 参数,统计了每个分组中元素的数量,并将结果封装为 Long 类型。运行结果如下:

{3=1, 5=2, 6=1, 10=1}

Collectors.groupingBy() 方法是 Java 中非常强大的一种分组操作,它能够对流中的元素按照指定的分类器进行分组,并且支持各种进一步处理方式,例如统计、聚合、排序等。

groupingByConcurrent(Function<? super T, ? extends K> classifier)

  Collectors.groupingByConcurrent() 方法和 Collectors.groupingBy() 方法非常相似,都是用于将流中的元素按照指定的分类器进行分组。和 Collectors.groupingBy() 不同的是,Collectors.groupingByConcurrent() 方法返回的是一个线程安全(concurrent)的 ConcurrentMap 对象。

groupingByConcurrent() 方法的使用方法和 groupingBy() 类似,也有两个重载形式。最简单的形式如下:

ConcurrentMap<K, List<T>> map = stream.collect(Collectors.groupingByConcurrent(classifier));

其中,

  • stream 是待处理的流;
  • classifier 是一个函数式接口,用于将流中的每个元素映射为一个分类键 K

例如,我们有一个字符串列表,并希望按照字符串长度分组:

List<String> list = Arrays.asList("apple", "banana", "cherry", "date", "elderberry");
ConcurrentMap<Integer, List<String>> map = list.parallelStream()
    .collect(Collectors.groupingByConcurrent(String::length));

在上面的代码中,我们使用 parallelStream() 方法将列表转换为一个并行流,以便在多线程环境下进行分组操作。运行结果如下:

{3=[date], 5=[apple, cherry], 6=[banana], 10=[elderberry]}

        需要注意的是,groupingByConcurrent() 方法和 groupingBy() 方法一样,返回的是一个 Map 对象,其中键是分类键,值则是由该分类键对应的元素构成的列表。在上述例子中,长度为 5 的字符串有两个,因此它们都被加入了同一个列表中。

  Collectors.groupingByConcurrent() 方法和 Collectors.groupingBy() 方法非常相似,可以看作是线程安全版和非线程安全版的分组操作。在多线程环境下,groupingByConcurrent() 方法具有更好的性能和并发能力,适合于处理大规模数据和高并发场景,但相应地会占用更多的系统资源。

mapping()

   Collectors.mapping() 方法是 Java 8 中新增的一个收集器(Collector)。它可以用于对流中的元素进行映射后,再使用其他收集器进行处理。

mapping() 方法的定义如下:

public static <T, U, A, R> Collector<T, ?, R> mapping(
    Function<? super T, ? extends U> mapper,
    Collector<? super U, A, R> downstream)

其中,

  • mapper 是一个函数式接口,用于将流中的每个元素进行映射;
  • downstream 是另一个收集器,用于对映射后的元素进行进一步的操作。

  mapping() 方法会对流中的元素应用 mapper 函数,并将结果传递给 downstream 收集器进行进一步处理。最终将结果进行合并,形成最终的结果。

        例如,我们有一个字符串列表,并希望统计每个字符串中字符的出现次数。可以使用 mapping() 方法将每个字符串映射为一个字符出现次数的 Map 对象,然后使用 toMap() 方法对所有的 Map 进行合并得到最终的结果:

List<String> list = Arrays.asList("apple", "banana", "cherry", "date", "elderberry");

Map<Character, Integer> resultMap = list.stream()
    .flatMapToInt(String::chars)     // 将每个字符串转换为字符流
    .mapToObj(c -> (char) c)         // 将每个字符转换为包装类型
    .collect(Collectors.mapping(
        Function.identity(),         // 将字符作为 KEY
        Collectors.groupingBy(c -> c, Collectors.summingInt(c -> 1)) // 统计每个字符出现的次数
    ))
    .entrySet().stream()
    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

        在上述代码中,我们首先使用 flatMapToInt() 方法将字符串转换为一个 IntStream 对象,然后使用 mapToObj() 方法将每个字符转换为包装类型。接着我们使用 mapping() 方法对每个字符进行了分组统计,得到了多个 Map 对象,最后使用 toMap() 方法将它们合并得到最终的结果。

        需要注意的是,在 mapping() 方法中,我们传递给第二个参数的是 Collectors.groupingBy() 方法,这表示我们先对元素进行了分组操作。而 groupingBy() 方法的第二个参数则是 Collectors.summingInt() 方法,表示我们对每组元素进行求和操作。

  Collectors.mapping() 方法非常灵活,可以与其他的收集器配合使用,实现更加复杂的数据处理操作

分区

partitioningBy(Predicate<? super T> predicate)

        Collectors.partitioningBy(Predicate<? super T> predicate) 是 Java 8 中的一个收集器 (Collector),它用于将 Stream 中的元素按照 Predicate 的条件进行分区,并将分区的结果保存到一个 Map 对象中。

        该方法的参数 predicate 是一个谓词 (Predicate),它表示对 Stream 中的元素进行筛选的条件,它的返回值是一个布尔类型。具体来说,如果该方法返回 true,则该元素应该被分到分区的 true 列表中;如果返回 false,则该元素应该被分到分区的 false 列表中。

        例如,假设有一个 Student 类型的列表 List<Student> students,我们可以使用 Collectors.partitioningBy() 方法将其按照学生的分数是否大于等于 60 分进行分区,并将分区的结果保存到一个 Map 对象中:

Map<Boolean, List<Student>> result = students.stream()
    .collect(Collectors.partitioningBy(s -> s.getScore() >= 60));

         上述代码中,我们通过 stream() 方法将 List 转换为 Stream,然后使用 Collectors.partitioningBy() 方法对 Stream 中的元素进行分区,将分区的结果保存到 Map<Boolean, List<Student>> 类型的 result 对象中。最终得到的 Map 对象中,键为 true 的部分包含了所有分数大于等于 60 分的学生,键为 false 的部分包含了所有分数小于 60 分的学生。

        当我们需要将 Stream 中的元素按照某一个属性进行分区时,可以使用方法引用的方式来代替 Lambda 表达式。例如,假设 Student 类型具有一个 boolean 类型的属性 isMale,表示该学生是否为男性,我们可以通过以下代码对学生进行分区:

Map<Boolean, List<Student>> result = students.stream()
    .collect(Collectors.partitioningBy(Student::isMale));

        上述代码中,Student::isMale 表示 Student 类型中的一个静态方法,用于返回该学生是否为男性。因此,我们可以将该方法作为 Predicate 参数传递给 Collectors.partitioningBy() 方法,实现按照学生的性别进行分区的功能。

        总之,Collectors.partitioningBy(Predicate<? super T> predicate) 是 Java 8 中一个非常有用的收集器,它可以将 Stream 中的元素按照任意的条件进行分区,并将分区的结果保存到一个 Map 对象中,为我们处理数据提供了很大的便利性。

partitioningBy(Predicate<? super T> predicate, Collector<? super T, A, D> downstream)

        Collectors.partitioningBy(Predicate<? super T> predicate, Collector<? super T, A, D> downstream) 是 Java 8 中的一个收集器 (Collector),它用于将 Stream 中的元素按照 Predicate 的条件进行分区,并对每个分区应用一个下游收集器 (downstream),将分区的结果保存到一个 Map 对象中。

        该方法的第一个参数 predicate 是一个谓词 (Predicate),表示对 Stream 中的元素进行筛选的条件。对符合条件的元素,将被分到分区的 true 列表中;反之,将被分到分区的 false 列表中。

        第二个参数 downstream 是一个下游收集器 (Collector),它将作用于每个分区的元素上。downstream 接收的类型为 T,中间累加结果的类型为 A,最终的返回值类型为 D。通常情况下,我们使用其他的收集器来作为 downstream,例如 Collectors.toList()、Collectors.toSet()、Collectors.summingInt() 等方法。

        下面,我们通过一个例子来解释 Collectors.partitioningBy(Predicate<? super T> predicate, Collector<? super T, A, D> downstream) 的用法。假设有一个 Person 类型的列表 List<Person> persons,我们需要将其中年龄大于等于 18 岁的人按照性别进行分区,并将每个分区中的人的姓名保存到一个 List<String> 中。可以采用如下代码实现:

Map<Boolean, List<String>> result = persons.stream()
    .collect(Collectors.partitioningBy(
        p -> p.getAge() >= 18,
        Collectors.mapping(Person::getName, Collectors.toList())));

        上述代码中,我们通过 stream() 方法将 List 转换为 Stream,然后使用 Collectors.partitioningBy() 方法对 Stream 中的元素进行分区,并将分区的结果保存到 Map<Boolean, List<String>> 类型的 result 对象中。其中,第一个参数 p -> p.getAge() >= 18 表示对年龄大于等于 18 的人进行分区,第二个参数 Collectors.mapping(Person::getName, Collectors.toList()) 表示将分区中的每个人的姓名映射到一个 List 中,并将这个 List 作为分区的值。通过这种方式,我们可以实现按照年龄和性别进行分区,并获取每个分区中的人的姓名列表。

        总之,Collectors.partitioningBy(Predicate<? super T> predicate, Collector<? super T, A, D> downstream) 是 Java 8 中一个非常有用的收集器,它可以将 Stream 中的元素按照任意的条件进行分区,并对每个分区应用一个下游收集器,将分区的结果保存到一个 Map 对象中,为我们处理数据提供了很大的便利性。同时,通过合理选择下游收集器,我们可以实现更加复杂的分区操作。文章来源地址https://www.toymoban.com/news/detail-465913.html

到了这里,关于Java8 Collectors类详解(一)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Java8新特性:Optional类(超详解)

    本博主将用CSDN记录软件开发求学之路上亲身所得与所学的心得与知识,有兴趣的小伙伴可以关注博主!也许一个人独行,可以走的很快,但是一群人结伴而行,才能走的更远! 到目前为止,臭名昭著的 空指针异常 是导致Java应用程序失败的最常见原因。以前,为了解决空指

    2023年04月09日
    浏览(42)
  • Java8之Function函数、BiFunction函数详解

    众所周知,Java8提供了一下非常重要的函数式接口。今天我们就来讲讲其中一个函数式接口----- Function 接口。 下面的代码就是Function接口的全部代码。接下来我们逐个分析一下。 @FunctionalInterface 表明该接口是一个函数式接口 T, R T 代表参数,R 代表返回值。 第一个方法------R

    2024年02月11日
    浏览(31)
  • 拥抱变化,面向Java17,Java8-18全系列特性详解

    文章目录: Java 8 新特性 Java 9 新特性 Java 10 新特性 Java 11 新特性 Java 12 新特性 Java 13 新特性 Java 14 新特性 Java 15 新特性 Java 16 新特性 Java 17 新特性 Java 18 新特性 💡 文章较长,建议点赞、收藏、评论后慢慢看,合理利用 “ 只看目录功能 ” 当我们大部分Javaer还沉浸在Java 8 的

    2024年01月16日
    浏览(38)
  • java8日期类LocalDate、LocalTime、LocalDateTime使用详解

    在 Java8 之前通常会使用 Date 结合 SimpleDateFormat 、 Calender 来处理时间和日期的相关需求。 但是这些 API 也存在明显的缺点: 可读性差、易用性差、使用起来冗余繁琐 java.util.Date 是非线程安全的 java.util.Date 存在千年虫问题、并且不支持国际化和时区、故大部分方法被声明为过

    2023年04月16日
    浏览(70)
  • Java8 时间处理API(Date Time API)详解

    在Java8之前,我们通常使用 java.util.Date 和 java.util.Calendar 类来处理日期和时间相关的操作,例如: 这种方式虽然可以实现功能,但是有一些缺点: 可变性: Date 和 Calendar 类都是可变的,这意味着它们的值可以被修改,这可能会导致一些线程安全和逻辑错误的问题。 可读性差

    2024年02月11日
    浏览(55)
  • 使用java8 新特性stream流对List<Map<String, Object>>集合进行遍历、过滤、查询、去重、排序、分组

    对于一个ListMapString, Object类型的数据,可以使用Java 8的新特性stream流来进行遍历、过滤、查询、去重、排序、分组等操作。 遍历: 过滤: 查询: 去重: 排序: 分组:

    2024年02月10日
    浏览(65)
  • Collectors.toMap使用详解

    在实际项目中我们经常会有 List 转 Map 操作,在过去(JAVA8以前)我们可能使用的是 for 循环遍历的方式,这种方式就不做过多赘述。这里主要讲解使用 Collectors.toMap 方式及使用过程需注意的地方,避免踩坑 三个重载的方法如下: 参数含义分别是: keyMapper:Key 的映射函数。 va

    2024年02月11日
    浏览(45)
  • Java流式操作——Collectors工具类

    Java中的Collectors工具类是用于收集流中的元素并生成结果的工具类。它提供了一系列静态方法,可以用于对流进行归约、分组、分区、转换等操作。 ● maxBy:获取流中最大元素;minBy:获取流中最小元素 ● joining:合并,将流中的元素,以字符串的形式拼接起来 ● summingInt:把流

    2024年02月02日
    浏览(45)
  • Collectors.groupingBy()进行分组时,分组值存在null值会报NPE(空指针)错误,使用时要注意

    1、使用Collectors.groupingBy()进行分组时,分组值存在null值。 解决办法:分组值为null时,默认值为空字符。

    2024年02月14日
    浏览(57)
  • 【Java基础】Stream 流中 Collectors.toMap 的用法

    Collectors.toMap() 方法是把 List 转 Map 的操作 1.1、如果不是对象,是数组,怎么转成map? 按照规范来写的话,最好所有toMap,都要将这个异常提前考虑进去,不然有时候会报重复主键异常,这也是正例的写法,上面的属于反例的写法。 2.1、Collectors.toMap 有三个重载方法:  参数解

    2024年02月14日
    浏览(44)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包