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 作为分区的值。通过这种方式,我们可以实现按照年龄和性别进行分区,并获取每个分区中的人的姓名列表。文章来源:https://www.toymoban.com/news/detail-465913.html
总之,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模板网!