技术标签: java
Collectors
类是用于对流进行收集和汇总的工具类。它提供了许多方法来对流进行分组、统计、转换、分区、连接、归约等操作,使得处理集合类数据变得更加方便。
在使用 Collectors
类时,我们可以通过调用其中的方法来实现对流的不同处理方式。例如,将流中的元素收集到一个 List 中,可以使用 toList()
方法;按照指定条件进行分组,可以使用 groupingBy()
方法;统计流中的元素个数,可以使用 counting()
方法等等。
此外,Collectors
类还支持自定义收集器,即我们可以根据自己的需求来编写实现了 Collector
接口的自定义收集器,然后直接在代码中使用。这个功能在一些复杂的应用场景下非常有用。
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
集合中,进一步满足我们对数据的处理需求。
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
集合中,进一步满足我们对数据的处理需求。
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()
方法在实际开发中非常常用,它可以方便地将流中的元素收集到指定类型的集合中,进一步满足我们对数据的处理需求。同时,该方法还非常灵活,可以根据实际需要传入不同类型的集合工厂来创建不同类型的集合。
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
中,并且提供了丰富的方式来处理重复键等问题。
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
中,并且提供了丰富的方式来处理重复键等问题。
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 中非常强大的一种分组操作,它能够对流中的元素按照指定的分类器进行分组,并且支持各种进一步处理方式,例如统计、聚合、排序等。
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()
方法具有更好的性能和并发能力,适合于处理大规模数据和高并发场景,但相应地会占用更多的系统资源。
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()
方法非常灵活,可以与其他的收集器配合使用,实现更加复杂的数据处理操作
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 对象中,为我们处理数据提供了很大的便利性。
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 对象中,为我们处理数据提供了很大的便利性。同时,通过合理选择下游收集器,我们可以实现更加复杂的分区操作。
文章浏览阅读645次。这个肯定是末尾的IDAT了,因为IDAT必须要满了才会开始一下个IDAT,这个明显就是末尾的IDAT了。,对应下面的create_head()代码。,对应下面的create_tail()代码。不要考虑爆破,我已经试了一下,太多情况了。题目来源:UNCTF。_攻防世界困难模式攻略图文
文章浏览阅读2.9k次,点赞3次,收藏10次。偶尔会用到,记录、分享。1. 数据库导出1.1 切换到dmdba用户su - dmdba1.2 进入达梦数据库安装路径的bin目录,执行导库操作 导出语句:./dexp cwy_init/[email protected]:5236 file=cwy_init.dmp log=cwy_init_exp.log 注释: cwy_init/init_123..._达梦数据库导入导出
文章浏览阅读1.9k次。1. 在官网上下载KindEditor文件,可以删掉不需要要到的jsp,asp,asp.net和php文件夹。接着把文件夹放到项目文件目录下。2. 修改html文件,在页面引入js文件:<script type="text/javascript" src="./kindeditor/kindeditor-all.js"></script><script type="text/javascript" src="./kindeditor/lang/zh-CN.js"_kindeditor.js
文章浏览阅读2.3k次,点赞6次,收藏14次。SPI的详情简介不必赘述。假设我们通过SPI发送0xAA,我们的数据线就会变为10101010,通过修改不同的内容,即可修改SPI中0和1的持续时间。比如0xF0即为前半周期为高电平,后半周期为低电平的状态。在SPI的通信模式中,CPHA配置会影响该实验,下图展示了不同采样位置的SPI时序图[1]。CPOL = 0,CPHA = 1:CLK空闲状态 = 低电平,数据在下降沿采样,并在上升沿移出CPOL = 0,CPHA = 0:CLK空闲状态 = 低电平,数据在上升沿采样,并在下降沿移出。_stm32g431cbu6
文章浏览阅读1.2k次,点赞2次,收藏8次。数据链路层习题自测问题1.数据链路(即逻辑链路)与链路(即物理链路)有何区别?“电路接通了”与”数据链路接通了”的区别何在?2.数据链路层中的链路控制包括哪些功能?试讨论数据链路层做成可靠的链路层有哪些优点和缺点。3.网络适配器的作用是什么?网络适配器工作在哪一层?4.数据链路层的三个基本问题(帧定界、透明传输和差错检测)为什么都必须加以解决?5.如果在数据链路层不进行帧定界,会发生什么问题?6.PPP协议的主要特点是什么?为什么PPP不使用帧的编号?PPP适用于什么情况?为什么PPP协议不_接收方收到链路层数据后,使用crc检验后,余数为0,说明链路层的传输时可靠传输
文章浏览阅读587次。软件测试工程师移民加拿大 无证移民,未受过软件工程师的教育(第1部分) (Undocumented Immigrant With No Education to Software Engineer(Part 1))Before I start, I want you to please bear with me on the way I write, I have very little gen...
文章浏览阅读304次。Thinkpad X250笔记本电脑,装的是FreeBSD,进入BIOS修改虚拟化配置(其后可能是误设置了安全开机),保存退出后系统无法启动,显示:secure boot failed ,把自己惊出一身冷汗,因为这台笔记本刚好还没开始做备份.....根据错误提示,到bios里面去找相关配置,在Security里面找到了Secure Boot选项,发现果然被设置为Enabled,将其修改为Disabled ,再开机,终于正常启动了。_安装完系统提示secureboot failure
文章浏览阅读10w+次,点赞93次,收藏352次。1、用strtok函数进行字符串分割原型: char *strtok(char *str, const char *delim);功能:分解字符串为一组字符串。参数说明:str为要分解的字符串,delim为分隔符字符串。返回值:从str开头开始的一个个被分割的串。当没有被分割的串时则返回NULL。其它:strtok函数线程不安全,可以使用strtok_r替代。示例://借助strtok实现split#include <string.h>#include <stdio.h&_c++ 字符串分割
文章浏览阅读2.3k次。1 .高斯日记 大数学家高斯有个好习惯:无论如何都要记日记。他的日记有个与众不同的地方,他从不注明年月日,而是用一个整数代替,比如:4210后来人们知道,那个整数就是日期,它表示那一天是高斯出生后的第几天。这或许也是个好习惯,它时时刻刻提醒着主人:日子又过去一天,还有多少时光可以用于浪费呢?高斯出生于:1777年4月30日。在高斯发现的一个重要定理的日记_2013年第四届c a组蓝桥杯省赛真题解答
文章浏览阅读851次,点赞17次,收藏22次。摘要:本文利用供需算法对核极限学习机(KELM)进行优化,并用于分类。
文章浏览阅读1.1k次。一、系统弱密码登录1、在kali上执行命令行telnet 192.168.26.1292、Login和password都输入msfadmin3、登录成功,进入系统4、测试如下:二、MySQL弱密码登录:1、在kali上执行mysql –h 192.168.26.129 –u root2、登录成功,进入MySQL系统3、测试效果:三、PostgreSQL弱密码登录1、在Kali上执行psql -h 192.168.26.129 –U post..._metasploitable2怎么进入
文章浏览阅读257次。本文将为初学者提供Python学习的详细指南,从Python的历史、基础语法和数据类型到面向对象编程、模块和库的使用。通过本文,您将能够掌握Python编程的核心概念,为今后的编程学习和实践打下坚实基础。_python人工智能开发从入门到精通pdf