流式处理是JAVA8的新特性之一,它能够让集合操作变得简洁了许多,通常我们需要多行代码才能完成的操作,借助于流式处理可以在一行中实现。比如我们希望对一个包含整数的集合中筛选出所有的偶数,并将其封装成为一个新的List返回,那么在java8之前,我们需要通过如下代码实现:
List<Integer> evens = new ArrayList<>();
for (final Integer num : nums) {
if (num % 2 == 0) {
evens.add(num);
}
}
通过java8的流式处理,我们可以将代码简化为:
List<Integer> evens = nums.stream().filter(num -> num % 2 == 0).collect(Collectors.toList());
先简单解释一下上面这行语句的含义,stream()
操作将集合转换成一个流,filter()
执行我们自定义的筛选处理,这里是通过lambda表达式筛选出所有偶数,最后我们通过collect()
对结果进行封装处理,并通过Collectors.toList()
指定其封装成为一个List集合返回。
由上面的例子可以看出,java8的流式处理极大的简化了对于集合的操作,实际上不光是集合,包括数组、文件等,只要是可以转换成流,我们都可以借助流式处理,类似于我们写SQL语句一样对其进行操作。java8通过内部迭代来实现对流的处理,一个流式处理可以分为三个部分:转换成流、中间操作、终端操作。如下图:
以集合为例,一个流式处理的操作我们首先需要调用stream()
函数将其转换成流,然后再调用相应的中间操作
达到我们需要对集合进行的操作,比如筛选、转换等,最后通过终端操作
对前面的结果进行封装,返回我们需要的形式。
我们定义一个简单的学生实体类,用于后面的例子演示:
public class Student {
/** 学号 */
private long id;
private String name;
private int age;
/** 年级 */
private int grade;
/** 专业 */
private String major;
/** 学校 */
private String school;
// 省略getter和setter
}
// 初始化
List<Student> students = new ArrayList<Student>() {
{
add(new Student(20160001, "孔明", 20, 1, "土木工程", "武汉大学"));
add(new Student(20160002, "伯约", 21, 2, "信息安全", "武汉大学"));
add(new Student(20160003, "玄德", 22, 3, "经济管理", "武汉大学"));
add(new Student(20160004, "云长", 21, 2, "信息安全", "武汉大学"));
add(new Student(20161001, "翼德", 21, 2, "机械与自动化", "华中科技大学"));
add(new Student(20161002, "元直", 23, 4, "土木工程", "华中科技大学"));
add(new Student(20161003, "奉孝", 23, 4, "计算机科学", "华中科技大学"));
add(new Student(20162001, "仲谋", 22, 3, "土木工程", "浙江大学"));
add(new Student(20162002, "鲁肃", 23, 4, "计算机科学", "浙江大学"));
add(new Student(20163001, "丁奉", 24, 5, "土木工程", "南京大学"));
}
};
过滤,顾名思义就是按照给定的要求对集合进行筛选满足条件的元素,java8提供的筛选操作包括:filter、distinct、limit、skip。
filter
在前面的例子中我们已经演示了如何使用filter,其定义为:Stream<T> filter(Predicate<? super T> predicate)
,filter接受一个谓词Predicate
,我们可以通过这个谓词定义筛选条件,在介绍lambda表达式时我们介绍过Predicate
是一个函数式接口,其包含一个test(T t)
方法,该方法返回boolean
。现在我们希望从集合students
中筛选出所有武汉大学的学生,那么我们可以通过filter来实现,并将筛选操作作为参数传递给filter:
List<Integer> evens = nums.stream()
.filter(num -> num % 2 == 0).distinct()
.collect(Collectors.toList());
distinct
distinct操作类似于我们在写SQL语句时,添加的DISTINCT
关键字,用于去重处理,distinct基于Object.equals(Object)
实现,回到最开始的例子,假设我们希望筛选出所有不重复的偶数,那么可以添加distinct操作:
List<Integer> evens = nums.stream()
.filter(num -> num % 2 == 0).distinct()
.collect(Collectors.toList());
limit
limit操作也类似于SQL语句中的LIMIT
关键字,不过相对功能较弱,limit返回包含前n个元素的流,当集合大小小于n时,则返回实际长度,比如下面的例子返回前两个专业为土木工程
专业的学生:
List<Student> civilStudents = students.stream()
.filter(student -> "土木工程".equals(student.getMajor())).limit(2)
.collect(Collectors.toList());
说到limit,不得不提及一下另外一个流操作:sorted
。该操作用于对流中元素进行排序,sorted要求待比较的元素必须实现Comparable
接口,如果没有实现也不要紧,我们可以将比较器作为参数传递给sorted(Comparator<? super T> comparator)
,比如我们希望筛选出专业为土木工程的学生,并按年龄从小到大排序,筛选出年龄最小的两个学生,那么可以实现为:
List<Student> sortedCivilStudents = students.stream()
.filter(student -> "土木工程".equals(student.getMajor())).sorted((s1, s2) -> s1.getAge() - s2.getAge())
.limit(2)
.collect(Collectors.toList());
skip
skip操作与limit操作相反,如同其字面意思一样,是跳过前n个元素,比如我们希望找出排序在2之后的土木工程专业的学生,那么可以实现为:
List<Student> civilStudents = students.stream()
.filter(student -> "土木工程".equals(student.getMajor()))
.skip(2)
.collect(Collectors.toList());
通过skip,就会跳过前面两个元素,返回由后面所有元素构造的流,如果n大于满足条件的集合的长度,则会返回一个空的集合。
在SQL中,借助SELECT
关键字后面添加需要的字段名称,可以仅输出我们需要的字段数据,而流式处理的映射操作也是实现这一目的,在java8的流式处理中,主要包含两类映射操作:map和flatMap。
map
举例说明,假设我们希望筛选出所有专业为计算机科学的学生姓名,那么我们可以在filter筛选的基础之上,通过map将学生实体映射成为学生姓名字符串,具体实现如下:
List<String> names = students.stream()
.filter(student -> "计算机科学".equals(student.getMajor()))
.map(Student::getName).collect(Collectors.toList());
除了上面这类基础的map,java8还提供了mapToDouble(ToDoubleFunction<? super T> mapper)
,mapToInt(ToIntFunction<? super T> mapper)
,mapToLong(ToLongFunction<? super T> mapper)
,这些映射分别返回对应类型的流,java8为这些流设定了一些特殊的操作,比如我们希望计算所有专业为计算机科学学生的年龄之和,那么我们可以实现如下:
int totalAge = students.stream()
.filter(student -> "计算机科学".equals(student.getMajor()))
.mapToInt(Student::getAge).sum();
通过将Student按照年龄直接映射为IntStream
,我们可以直接调用提供的sum()
方法来达到目的,此外使用这些数值流的好处还在于可以避免jvm装箱操作所带来的性能消耗。
flatMap
flatMap与map的区别在于 flatMap是将一个流中的每个值都转成一个个流,然后再将这些流扁平化成为一个流 。举例说明,假设我们有一个字符串数组String[] strs = {"java8", "is", "easy", "to", "use"};
,我们希望输出构成这一数组的所有非重复字符,那么我们可能首先会想到如下实现:
List<String[]> distinctStrs = Arrays.stream(strs)
.map(str -> str.split("")) // 映射成为Stream<String[]>
.distinct()
.collect(Collectors.toList());
在执行map操作以后,我们得到是一个包含多个字符串(构成一个字符串的字符数组)的流,此时执行distinct操作是基于在这些字符串数组之间的对比,所以达不到我们希望的目的,此时的输出为:
[j, a, v, a, 8] [i, s] [e, a, s, y] [t, o] [u, s, e]
distinct只有对于一个包含多个字符的流进行操作才能达到我们的目的,即对Stream<String>
进行操作。此时flatMap就可以达到我们的目的:
List<String> distinctStrs = Arrays.stream(strs)
.map(str -> str.split("")) // 映射成为Stream<String[]>
.flatMap(Arrays::stream) // 扁平化为Stream<String>
.distinct()
.collect(Collectors.toList());
flatMap将由map映射得到的Stream<String[]>
,转换成由各个字符串数组映射成的流Stream<String>
,再将这些小的流扁平化成为一个由所有字符串构成的大流Steam<String>
,从而能够达到我们的目的。
与map类似,flatMap也提供了针对特定类型的映射操作:flatMapToDouble(Function<? super T,? extends DoubleStream> mapper)
,flatMapToInt(Function<? super T,? extends IntStream> mapper)
,flatMapToLong(Function<? super T,? extends LongStream> mapper)
。
终端操作是流式处理的最后一步,我们可以在终端操作中实现对流查找、归约等操作。
allMatch
allMatch用于检测是否全部都满足指定的参数行为,如果全部满足则返回true,例如我们希望检测是否所有的学生都已满18周岁,那么可以实现为:
boolean isAdult = students.stream().allMatch(student -> student.getAge() >= 18);
anyMatch
anyMatch则是检测是否存在一个或多个满足指定的参数行为,如果满足则返回true,例如我们希望检测是否有来自武汉大学的学生,那么可以实现为:
boolean hasWhu = students.stream().anyMatch(student -> "武汉大学".equals(student.getSchool()));
noneMathch
noneMatch用于检测是否不存在满足指定行为的元素,如果不存在则返回true,例如我们希望检测是否不存在专业为计算机科学的学生,可以实现如下:
boolean noneCs = students.stream().noneMatch(student -> "计算机科学".equals(student.getMajor()));
findFirst
findFirst用于返回满足条件的第一个元素,比如我们希望选出专业为土木工程的排在第一个学生,那么可以实现如下:
Optional<Student> optStu = students.stream().filter(student -> "土木工程".equals(student.getMajor())).findFirst();
findFirst不携带参数,具体的查找条件可以通过filter设置,此外我们可以发现findFirst返回的是一个Optional类型。
findAny
findAny相对于findFirst的区别在于,findAny不一定返回第一个,而是返回任意一个,比如我们希望返回任意一个专业为土木工程的学生,可以实现如下:
Optional<Student> optStu = students.stream().filter(student -> "土木工程".equals(student.getMajor())).findAny();
实际上对于顺序流式处理而言,findFirst和findAny返回的结果是一样的,至于为什么会这样设计,是因为在下一篇我们介绍的并行流式处理,当我们启用并行流式处理的时候,查找第一个元素往往会有很多限制,如果不是特别需求,在并行流式处理中使用findAny的性能要比findFirst好。
前面的例子中我们大部分都是通过collect(Collectors.toList())
对数据封装返回,如我的目标不是返回一个新的集合,而是希望对经过参数化操作后的集合进行进一步的运算,那么我们可用对集合实施归约操作。java8的流式处理提供了reduce
方法来达到这一目的。
前面我们通过mapToInt将Stream<Student>
映射成为IntStream
,并通过IntStream
的sum方法求得所有学生的年龄之和,实际上我们通过归约操作,也可以达到这一目的,实现如下:
// 前面例子中的方法
int totalAge = students.stream()
.filter(student -> "计算机科学".equals(student.getMajor()))
.mapToInt(Student::getAge).sum();
// 归约操作
int totalAge = students.stream()
.filter(student -> "计算机科学".equals(student.getMajor()))
.map(Student::getAge)
.reduce(0, (a, b) -> a + b);
// 进一步简化
int totalAge2 = students.stream()
.filter(student -> "计算机科学".equals(student.getMajor()))
.map(Student::getAge)
.reduce(0, Integer::sum);
// 采用无初始值的重载版本,需要注意返回Optional
Optional<Integer> totalAge = students.stream()
.filter(student -> "计算机科学".equals(student.getMajor()))
.map(Student::getAge)
.reduce(Integer::sum); // 去掉初始值
前面利用collect(Collectors.toList())
是一个简单的收集操作,是对处理结果的封装,对应的还有toSet
、toMap
,以满足我们对于结果组织的需求。这些方法均来自于java.util.stream.Collectors
,我们可以称之为收集器。
收集器也提供了相应的归约操作,但是与reduce在内部实现上是有区别的,收集器更加适用于可变容器上的归约操作,这些收集器广义上均基于Collectors.reducing()
实现。
例1:求学生的总人数
long count = students.stream().collect(Collectors.counting());
// 进一步简化
long count = students.stream().count();
例2:求年龄的最大值和最小值
// 求最大年龄
Optional<Student> olderStudent = students.stream().collect(Collectors.maxBy((s1, s2) -> s1.getAge() - s2.getAge()));
// 进一步简化
Optional<Student> olderStudent2 = students.stream().collect(Collectors.maxBy(Comparator.comparing(Student::getAge)));
// 求最小年龄
Optional<Student> olderStudent3 = students.stream().collect(Collectors.minBy(Comparator.comparing(Student::getAge)));
例3:求年龄总和
int totalAge4 = students.stream().collect(Collectors.summingInt(Student::getAge));
对应的还有summingLong
、summingDouble
。
例4:求年龄的平均值
double avgAge = students.stream().collect(Collectors.averagingInt(Student::getAge));
对应的还有averagingLong
、averagingDouble
。
例5:一次性得到元素个数、总和、均值、最大值、最小值
IntSummaryStatistics statistics = students.stream().collect(Collectors.summarizingInt(Student::getAge));
输出:
IntSummaryStatistics{count=10, sum=220, min=20, average=22.000000, max=24}
对应的还有summarizingLong
、summarizingDouble
。
例6:字符串拼接
String names = students.stream().map(Student::getName).collect(Collectors.joining());
// 输出:孔明伯约玄德云长翼德元直奉孝仲谋鲁肃丁奉
String names = students.stream().map(Student::getName).collect(Collectors.joining(", "));
// 输出:孔明, 伯约, 玄德, 云长, 翼德, 元直, 奉孝, 仲谋, 鲁肃, 丁奉
在数据库操作中,我们可以通过GROUP BY
关键字对查询到的数据进行分组,java8的流式处理也为我们提供了这样的功能Collectors.groupingBy
来操作集合。比如我们可以按学校对上面的学生进行分组:
Map<String, List<Student>> groups = students.stream().collect(Collectors.groupingBy(Student::getSchool));
groupingBy
接收一个分类器Function<? super T, ? extends K> classifier
,我们可以自定义分类器来实现需要的分类效果。
上面演示的是一级分组,我们还可以定义多个分类器实现 多级分组,比如我们希望在按学校分组的基础之上再按照专业进行分组,实现如下:
Map<String, Map<String, List<Student>>> groups2 = students.stream().collect(
Collectors.groupingBy(Student::getSchool, // 一级分组,按学校
Collectors.groupingBy(Student::getMajor))); // 二级分组,按专业
实际上在groupingBy
的第二个参数不是只能传递groupingBy,还可以传递任意Collector
类型,比如我们可以传递一个Collector.counting
,用以统计每个组的个数:
Map<String, Long> groups = students.stream().collect(Collectors.groupingBy(Student::getSchool, Collectors.counting()));
如果我们不添加第二个参数,则编译器会默认帮我们添加一个Collectors.toList()
。
分区可以看做是分组的一种特殊情况,在分区中key只有两种情况:true或false,目的是将待分区集合按照条件一分为二,java8的流式处理利用ollectors.partitioningBy()
方法实现分区,该方法接收一个谓词,例如我们希望将学生分为武大学生和非武大学生,那么可以实现如下:
Map<Boolean, List<Student>> partition = students.stream().collect(Collectors.partitioningBy(student -> "武汉大学".equals(student.getSchool())));
分区相对分组的优势在于,我们可以同时得到两类结果,在一些应用场景下可以一步得到我们需要的所有结果,比如将数组分为奇数和偶数。
以上介绍的所有收集器均实现自接口java.util.stream.Collector
,该接口的定义如下:
public interface Collector<T, A, R> {
/**
* A function that creates and returns a new mutable result container.
*
* @return a function which returns a new, mutable result container
*/
Supplier<A> supplier();
/**
* A function that folds a value into a mutable result container.
*
* @return a function which folds a value into a mutable result container
*/
BiConsumer<A, T> accumulator();
/**
* A function that accepts two partial results and merges them. The
* combiner function may fold state from one argument into the other and
* return that, or may return a new result container.
*
* @return a function which combines two partial results into a combined
* result
*/
BinaryOperator<A> combiner();
/**
* Perform the final transformation from the intermediate accumulation type
* {@code A} to the final result type {@code R}.
*
* <p>If the characteristic {@code IDENTITY_TRANSFORM} is
* set, this function may be presumed to be an identity transform with an
* unchecked cast from {@code A} to {@code R}.
*
* @return a function which transforms the intermediate result to the final
* result
*/
Function<A, R> finisher();
/**
* Returns a {@code Set} of {@code Collector.Characteristics} indicating
* the characteristics of this Collector. This set should be immutable.
*
* @return an immutable set of collector characteristics
*/
Set<Characteristics> characteristics();
}
我们也可以实现该接口来定义自己的收集器,此处不再展开。
流式处理中的很多都适合采用 分而治之 的思想,从而在处理集合较大时,极大的提高代码的性能,java8的设计者也看到了这一点,所以提供了 并行流式处理。上面的例子中我们都是调用stream()
方法来启动流式处理,java8还提供了parallelStream()
来启动并行流式处理,parallelStream()
本质上基于java7的Fork-Join框架实现,其默认的线程数为宿主机的内核数。
启动并行流式处理虽然简单,只需要将stream()
替换成parallelStream()
即可,但既然是并行,就会涉及到多线程安全问题,所以在启用之前要先确认并行是否值得(并行的效率不一定高于顺序执行),另外就是要保证线程安全。此两项无法保证,那么并行毫无意义,毕竟结果比速度更加重要,以后有时间再来详细分析一下并行流式数据处理的具体实现和最佳实践。
文章浏览阅读5.8k次,点赞4次,收藏19次。CC2530定时器1CC2530有5个定时器(定时器1,定时器2,定时器3,定时器4,睡眠定时器),定时器1是一个16位定时器,具有一个可编程的分频器,一个16位周期值,和五个各自可编程的计数器/捕获通道,每个都有一个16位比较值。..._t1cctl0
文章浏览阅读63次。在JSP中一共有9个隐含对象,这个9个对象我可以在JSP中直接使用。因为在service方法已经对这个九个隐含对象进行声明及赋值,所以可以在JSP中直接使用。 - pageContext 类型:PageContext 代表:当前页面的上下文 作用:可以获取到页面中的其他隐含对象,同时它还是一个域对象。 - request 类型:HttpServlet..._jsp中9个隐含对象
文章浏览阅读1.6w次,点赞23次,收藏141次。Android开发之打包APK详解_安卓打包apk
文章浏览阅读3.7k次,点赞2次,收藏6次。错误回顾网关的配置server: port: 80spring: application: name: api-gateway#springCloudgateway配置项对相应 GatewayPropweties cloud: # 网关配置 gateway: # 路由配置:对应RouteDefinition数组 routes: - id: desk-route #路由的编号,保证是唯一的 # _gateway 404
文章浏览阅读87次。例如nth_element(arr, arr+5, arr+10);是将从小到大排序后应该在arr[5]的元素放在arr[5]这个位置上。若要寻找第k大的数,nth_element(数组名,数组名+元素个数-k,数组名+元素个数)其用法为:函数语句:nth_element(数组名,数组名+第k个元素,数组名+元素个数)冒泡是每次将0~n-i范围内的最大数放在arr[n-1-i]位置,i代表了冒泡的次数。c++的STL里也有快速选择的函数nth_element()快速选择是用于分开较大的数和较小的数。_c++实现一行数中任意两个乘积最大
文章浏览阅读786次。安装开发c/c++的库,命令:==apt install _linux安装c++ mysql库
文章浏览阅读3.1k次。前情提示:在上篇博文中,我将一个使用GUI-Guider生成的图形界面移植到了ESP32设备上。显示成功,详情参见:如何将使用GUI-Guider生成的LVGL移植到ESP32https://blog.csdn.net/QTRPio/article/details/124120432背景:但是我使用GUI-Guider生成的图形界面还包含了几个图片按键: 条码识别; 手势识别;..._lvgl adc-button
文章浏览阅读1.3w次,点赞2次,收藏12次。BLE 协议架构总体上分成3块,从下到上分别是:控制器(Controller),主机(Host) 和应用端(Apps);3者可以在同一芯片类实现,也可以分不同芯片内实现,控制器(Controller)是处理射频数据解析,接收和发送,主机(Host)是控制不同设备之间如何进行数据交换;应用端(Apps)实现具体应用。控制器ControllerController实现射频相关的模拟和数_ble 协议
文章浏览阅读3.7k次,点赞73次,收藏284次。本文转载自 仟语仟寻,作者 霍仟这几天抽空把张一鸣的所有微博看了一遍,发现2010年的微博最好,就是他30岁左右的时候,那时候刚创业没多久,在微博上认真分享自己的思考和观点。到了2012年附近,开始做今日头条,每天都是大量转发今日头条上的文章到微博,干货变少了。后面就更新得越来越少。我从他的微博中,试图找到他成功的钥匙,得到了一些只言片语,但是仅仅是这些只言片语,我都觉得对我的启发很大。他从南开大学毕业,妻子是大学同学,毕业后去过微软,后来从微软离职,然后去过饭否,应该跟过王兴王慧文一阵子,后来_张一鸣微博干货
文章浏览阅读881次。2019独角兽企业重金招聘Python工程师标准>>> ..._unidac 帮助
文章浏览阅读1.1w次,点赞9次,收藏15次。报错信息:[root@localhost ~]# yum install bind bind-utils.x86_64 -y已加载插件:fastestmirror, langpacksCould not retrieve mirrorlist http://mirrorlist.centos.org/?release=7&arch=x86_64&repo=os&infra=stock error was14: curl#6 - "Could not resolve hos_could not resolve host: mirrors.cqu.edu.cn; unknown error
文章浏览阅读484次。技术分级自动驾驶技术分为多个等级,目前国内外产业界采用较多的为美国汽车工程师协会(SAE)和美国高速公路安全管理局(NHTSA)推出的分类标准。按照SAE的标准,自动驾驶汽车视智能化、自动化程度水平分为6个等级:无自动化(L0)、驾驶支援(L1)、部分自动化(L2)、有条件自动化(L3)、高度自动化(L4)和完全自动化(L5)。两种不同分类标准的主要区别在于完全自动驾驶场景下,SAE更加细分了自动..._智能驾驶