目录
目标
操作数据
相关依赖
中间方法
distinct
filter
map
flatMap
limit
skip
sorted
终止方法
allMatch
anyMatch
collect
findAny
findFirst
forEach
max/min
noneMatch
reduce
Collectors的方法
averaging
collectingAndThen
countIng
groupingBy
joining
mapping
maxBy/minBy
partitioningBy
summarizing
项目下载地址
目标
熟练使用stream操作集合,能通过例题举一反三,合理地将案例融入到实际工作中。
操作数据
package com.stream.data.bean;
import lombok.Data;
@Data
public class Student {
private String name;
private int age;
private boolean sex;
//语文分数
private float chineseScore;
//数学分数
private float mathScore;
public Student(String name,int age,boolean sex,float chineseScore,float mathScore){
this.name=name;
this.age=age;
this.sex=sex;
this.chineseScore=chineseScore;
this.mathScore=mathScore;
}
public Student(String name,int age,boolean sex){
this.name=name;
this.age=age;
this.sex=sex;
}
public Student(int age){
this.age=age;
};
}
package com.stream.data;
import com.stream.data.bean.Student;
import java.util.*;
public class StreamData {
//姓名集合
public static List nameList;
public static List animalList;
public static List studentInfoList;
public static List numList;
public static List numContainNullList;
public static List numAllNullList;
public static List numDoubleList;
public static List fingerGuessingList;
public static List
相关依赖
com.alibaba
fastjson
1.2.47
commons-lang
commons-lang
2.6
org.apache.commons
commons-collections4
4.4
com.google.code.gson
gson
2.8.6
com.alibaba
fastjson
1.2.75
org.springframework.boot
spring-boot-starter-web
org.projectlombok
lombok
true
org.springframework.boot
spring-boot-starter-test
test
com.vaadin.external.google
android-json
0.0.20131108.vaadin1
compile
中间方法
distinct
com.alibaba fastjson1.2.47 commons-lang commons-lang2.6 org.apache.commons commons-collections44.4 com.google.code.gson gson2.8.6 com.alibaba fastjson1.2.75 org.springframework.boot spring-boot-starter-weborg.projectlombok lomboktrue org.springframework.boot spring-boot-starter-testtest com.vaadin.external.google android-json0.0.20131108.vaadin1 compile
中间方法
distinct
作用:过滤重复数据。
需求一:过滤集合中重复的姓名。
方案:
public static void distinctName() {
List nameList = StreamData.nameList;
System.out.println("原来的集合:"+nameList);
List list = nameList.stream().distinct().collect(
Collectors.toList()
);
System.out.println("现在的集合:"+list);
}
返回结果:
原来的集合:[张三, null, null, 李四, 李四, 王五, 张三丰, 李明, 陈小东, 小张] 现在的集合:[张三, null, 李四, 王五, 张三丰, 李明, 陈小东, 小张]
需求二:根据姓名,过滤掉重复的数据。
方案:
public staticPredicate distinct(Function super T, ?> keyExtractor) { Set
原始数据:
[
{
"sex": true,
"name": "张三",
"chineseScore": 0,
"mathScore": 0,
"age": 12
},
{
"sex": true,
"name": "李四",
"chineseScore": 0,
"mathScore": 0,
"age": 13
},
{
"sex": false,
"name": "王五",
"chineseScore": 0,
"mathScore": 0,
"age": 12
},
{
"sex": true,
"name": "赵六",
"chineseScore": 0,
"mathScore": 0,
"age": 14
},
{
"sex": false,
"name": "钱七",
"chineseScore": 0,
"mathScore": 0,
"age": 12
},
{
"sex": false,
"name": "钱七",
"chineseScore": 0,
"mathScore": 0,
"age": 16
},
{
"sex": false,
"name": "钱七",
"chineseScore": 0,
"mathScore": 0,
"age": 16
},
{
"sex": false,
"chineseScore": 0,
"mathScore": 0,
"age": 16
},
{
"sex": false,
"name": "",
"chineseScore": 0,
"mathScore": 0,
"age": 19
},
{
"sex": false,
"chineseScore": 0,
"mathScore": 0,
"age": 16
}
]
返回结果:
[
{
"sex": true,
"name": "张三",
"chineseScore": 0,
"mathScore": 0,
"age": 12
},
{
"sex": true,
"name": "李四",
"chineseScore": 0,
"mathScore": 0,
"age": 13
},
{
"sex": false,
"name": "王五",
"chineseScore": 0,
"mathScore": 0,
"age": 12
},
{
"sex": true,
"name": "赵六",
"chineseScore": 0,
"mathScore": 0,
"age": 14
},
{
"sex": false,
"name": "钱七",
"chineseScore": 0,
"mathScore": 0,
"age": 12
},
{
"sex": false,
"name": "null",
"chineseScore": 0,
"mathScore": 0,
"age": 16
}
]
filter
作用:过滤掉不符合条件的数据。
需求一:筛选出集合中名字里有”张“的数据。
方案:
public static void containsName() {
List nameList = StreamData.nameList;
System.out.println("初始的数据:"+nameList);
List list = nameList.stream().filter(
str -> StringUtils.isNotBlank(str) && str.contains("张")
).collect(
Collectors.toList()
);
System.out.println("过滤后的数据:"+list);
}
返回结果:
初始的数据:[张三, null, null, 李四, 李四, 王五, 张三丰, 李明, 陈小东, 小张] 过滤后的数据:[张三, 张三丰, 小张]
需求二:筛选出集合中姓“张”的数据。
方案:
public static void containsName2() {
List nameList = StreamData.nameList;
System.out.println("初始的数据:"+nameList);
List list = nameList.stream().filter(
str -> StringUtils.isNotBlank(str) && "张".equals(str.substring(0,1))
).collect(
Collectors.toList()
);
System.out.println("过滤后的数据:"+list);
}
返回结果:
初始的数据:[张三, null, null, 李四, 李四, 王五, 张三丰, 李明, 陈小东, 小张] 过滤后的数据:[张三, 张三丰]
需求三:过滤掉集合中18岁以下的学生。
方案:
public static void containsName3() {
List studentInfoList=StreamData.studentInfoList;
JSONArray array = JSONArray.parseArray(JSON.toJSONString(studentInfoList));
System.out.println(array);
List studentFilterList = studentInfoList.stream().filter(
student -> student.getAge() > 18
).collect(
Collectors.toList()
);
JSONArray array2 = JSONArray.parseArray(JSON.toJSONString(studentFilterList));
System.out.println(array2);
}
原始数据:
[
{
"sex": true,
"name": "张三",
"chineseScore": 0,
"mathScore": 0,
"age": 12
},
{
"sex": true,
"name": "李四",
"chineseScore": 0,
"mathScore": 0,
"age": 13
},
{
"sex": false,
"name": "王五",
"chineseScore": 0,
"mathScore": 0,
"age": 12
},
{
"sex": true,
"name": "赵六",
"chineseScore": 0,
"mathScore": 0,
"age": 14
},
{
"sex": false,
"name": "钱七",
"chineseScore": 0,
"mathScore": 0,
"age": 12
},
{
"sex": false,
"name": "钱七",
"chineseScore": 0,
"mathScore": 0,
"age": 16
},
{
"sex": false,
"name": "钱七",
"chineseScore": 0,
"mathScore": 0,
"age": 16
},
{
"sex": false,
"chineseScore": 0,
"mathScore": 0,
"age": 16
},
{
"sex": false,
"name": "",
"chineseScore": 0,
"mathScore": 0,
"age": 19
},
{
"sex": false,
"chineseScore": 0,
"mathScore": 0,
"age": 16
}
]
返回结果:
[
{
"sex": false,
"name": "",
"chineseScore": 0,
"mathScore": 0,
"age": 19
}
]
map
作用:对流中所有元素做统一处理。
需求一:取出学生集合中的所有人的姓名,并在姓名前加“123班_”前缀。
方案:
public static void updateBean() {
List studentInfoList = StreamData.studentInfoList;
List list = studentInfoList.stream().map(
stu-> "123班_"+stu.getName()
).collect(Collectors.toList());
System.out.println(list);
}
返回结果:
[123班_张三, 123班_李四, 123班_王五, 123班_赵六, 123班_钱七, 123班_钱七, 123班_钱七, 123班_null, 123班_, 123班_null]
flatMap
作用:把集合内容扁平化。
需求一:拆分集合中的每个元素。
方案:
public static void flatMapTest() {
List nameList = StreamData.nameList;
System.out.println("原来的数据:"+nameList);
List collect = nameList.stream().flatMap(
str -> {
if (StringUtils.isBlank(str)) {
str = "";
}
Stream sorted = Arrays.stream(str.split(""));
return sorted;
}
).collect(
Collectors.toList()
);
System.out.println("处理后的数据:"+collect);
}
返回结果:
原来的数据:[张三, null, null, 李四, 李四, 王五, 张三丰, 李明, 陈小东, 小张] 处理后的数据:[张, 三, , , 李, 四, 李, 四, 王, 五, 张, 三, 丰, 李, 明, 陈, 小, 东, 小, 张]
需求二:两次猜拳,石头/剪刀/布一共有多少种组合。
方案:
public static void flatMapTest2() {
List list = StreamData.fingerGuessingList;
List> collect = list.stream().flatMap(
item -> list.stream().map(
item2 -> Arrays.asList(item, item2)
)
).collect(
Collectors.toList()
);
System.out.println(collect);
}
返回结果:
[[石头, 石头], [石头, 剪刀], [石头, 布], [剪刀, 石头], [剪刀, 剪刀], [剪刀, 布], [布, 石头], [布, 剪刀], [布, 布]]
limit
作用:获取流中前n条数据。
需求一:获取集合中前2条数据。
方案:
public static void limit() {
List nameList = StreamData.nameList;
System.out.println("初始数据"+nameList);
List list = nameList.stream().limit(2).collect(Collectors.toList());
System.out.println("结果数据"+list);
}
返回结果:
初始数据[张三, null, null, 李四, 李四, 王五, 张三丰, 李明, 陈小东, 小张] 结果数据[张三, null]
skip
作用:跳过流中前n条数据。
需求一:跳过流中前2条数据。
方案:
public static void skip() {
List nameList = StreamData.nameList;
System.out.println("原来的集合:"+nameList);
List list = nameList.stream().skip(2).collect(Collectors.toList());
System.out.println("现在的集合:"+list);
}
返回结果:
原来的集合:[张三, null, null, 李四, 李四, 王五, 张三丰, 李明, 陈小东, 小张] 结果数据:[null, 李四, 李四, 王五, 张三丰, 李明, 陈小东, 小张]
sorted
作用:对流排序(默认升序)。
需求一:升序排序集合的元素。
方案:
public static void ascList() {
List numList = StreamData.numList;
System.out.println("原来的集合:"+numList);
List list = numList.stream().sorted().collect(Collectors.toList());
System.out.println("结果数据:"+list);
}
返回结果:
原来的集合:[1, 2, 3, 6, 22, 8, 3, 0, 48] 结果数据:[0, 1, 2, 3, 3, 6, 8, 22, 48]
需求二:降序序排序集合的元素。
方案:
public static void descList() {
List numList = StreamData.numList;
System.out.println("原来的集合:"+numList);
List list = numList.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
System.out.println("结果数据:"+list);
}
返回结果:
原来的集合:[1, 2, 3, 6, 22, 8, 3, 0, 48] 结果数据:[48, 22, 8, 6, 3, 3, 2, 1, 0]
需求三:中文排序,中文姓氏生母升序排序,如果是姓名为null,则排序到最后面。
方案:
public static void sortNameAsc() {
List nameList = StreamData.nameList;
System.out.println("原来的集合:" + nameList);
List list = nameList.stream().sorted(
Comparator.nullsLast(
Collator.getInstance(Locale.CHINA)
)
).collect(
Collectors.toList()
);
System.out.println("结果数据:"+list);
}
返回结果:
原来的集合:[张三, null, null, 李四, 李四, 王五, 张三丰, 李明, 陈小东, 小张] 结果数据:[陈小东, 李明, 李四, 李四, 王五, 小张, 张三, 张三丰, null, null]
需求四:中文排序,中文姓氏生母降序排序,如果是姓名为null,则排序到最后面。
方案:
public static void sortNameDesc() {
List nameList = StreamData.nameList;
System.out.println("原来的集合:" + nameList);
List list = nameList.stream().sorted(
Comparator.nullsLast(
Collections.reverseOrder(Collator.getInstance(Locale.CHINA))
)
).collect(Collectors.toList());
System.out.println("结果数据:"+list);
}
返回结果:
原来的集合:[张三, null, null, 李四, 李四, 王五, 张三丰, 李明, 陈小东, 小张] 结果数据:[张三丰, 张三, 小张, 王五, 李四, 李四, 李明, 陈小东, null, null]
终止方法
allMatch
作用:检查流中所有元素是否匹配。都匹配返回true,有一个不匹配返回false。与noneMatch相反。
需求一:检查集合是否所有元素不为空。
方案:
public static void check() {
List list = StreamData.nameList;
System.out.println("原始数据:"+list);
boolean boo = list.stream().allMatch(
name -> StringUtils.isNotBlank(name)
);
System.out.println("返回结果:"+boo);
}
返回结果:
原始数据:[张三, null, null, 李四, 李四, 王五, 张三丰, 李明, 陈小东, 小张] 返回结果:false
需求二:检查学生集合中是否学生都小于18岁。
方案:
public static void check2() {
List list = StreamData.studentInfoList;
JSONArray array = JSONArray.parseArray(JSON.toJSONString(list));
System.out.println("原始数据:"+array);
boolean boo = list.stream().allMatch(
student -> student != null &&student.getAge()<18
);
System.out.println("返回结果:"+boo);
}
原始数据:
[
{
"sex": true,
"name": "张三",
"chineseScore": 0,
"mathScore": 0,
"age": 12
},
{
"sex": true,
"name": "李四",
"chineseScore": 0,
"mathScore": 0,
"age": 13
},
{
"sex": false,
"name": "王五",
"chineseScore": 0,
"mathScore": 0,
"age": 12
},
{
"sex": true,
"name": "赵六",
"chineseScore": 0,
"mathScore": 0,
"age": 14
},
{
"sex": false,
"name": "钱七",
"chineseScore": 0,
"mathScore": 0,
"age": 12
},
{
"sex": false,
"name": "钱七",
"chineseScore": 0,
"mathScore": 0,
"age": 16
},
{
"sex": false,
"name": "钱七",
"chineseScore": 0,
"mathScore": 0,
"age": 16
},
{
"sex": false,
"chineseScore": 0,
"mathScore": 0,
"age": 16
},
{
"sex": false,
"name": "",
"chineseScore": 0,
"mathScore": 0,
"age": 19
},
{
"sex": false,
"chineseScore": 0,
"mathScore": 0,
"age": 16
}
]
返回结果:
返回结果:false
anyMatch
作用:检查流中是否至少有一个元素匹配。
需求一:检查集合中是否有叫“张三”的人。
方案:
public static void check() {
List list = StreamData.nameList;
System.out.println("原始数据:"+list);
boolean boo = list.stream().anyMatch(
name -> StringUtils.isBlank(name) ? false : "张三".equals(name)
);
System.out.println("返回结果:"+boo);
}
返回结果:
原始数据:[张三, null, null, 李四, 李四, 王五, 张三丰, 李明, 陈小东, 小张] 返回结果:true
collect
作用:收集器,将流转换为指定格式。
需求一:将数组转换成List。
方案:
public static void toList(){
String[] nameArr=StreamData.nameArr;
System.out.println("原始数据:");
for (String s : nameArr) {
System.out.println(s);
}
List list = Arrays.stream(nameArr).collect(Collectors.toList());
System.out.println("返回结果:"+list);
}
返回结果:
原始数据: 阿里巴巴 腾讯 字节跳动 爱奇艺 返回结果:[阿里巴巴, 腾讯, 字节跳动, 爱奇艺]
需求二:将数List转换成Set。
方案:
public static void toSet(){
List list=StreamData.nameList;
System.out.println("原始数据:"+list);
Set set = list.stream().collect(Collectors.toSet());
System.out.println("返回结果:"+set);
}
返回结果:
原始数据:[张三, null, null, 李四, 李四, 王五, 张三丰, 李明, 陈小东, 小张] 返回结果:[null, 李四, 张三, 王五, 张三丰, 陈小东, 小张, 李明]
需求三:将数List转换成Map。
方案:
public static void toMap(){
List list=StreamData.nameList;
System.out.println("原始数据:"+list);
Map map = list.stream().collect(
Collectors.toMap(
//设置key
key -> UUID.randomUUID()+"",
//设置value
value -> StringUtils.isNotBlank(value)?value:"",
//如果key重复则新的覆盖旧的。
(oldValue, newValue) -> newValue
));
JSONObject json = JSONObject.parseObject(JSON.toJSONString(map));
System.out.println("结果数据:"+json);
}
返回结果:
原始数据:[张三, null, null, 李四, 李四, 王五, 张三丰, 李明, 陈小东, 小张]
结果数据:
{
"e436fdd9-e7f1-4078-874a-be4c2e115fde": "李四",
"33075304-e1b5-4a22-bb82-f99122b46f12": "小张",
"6373dc53-f231-4bc9-a69b-596561712ee7": "陈小东",
"f0cfddcc-d8c2-4504-a62b-ce7c59faaf1b": "",
"6f67d905-1d5b-417f-a1ad-997e5370ef72": "李四",
"aff28097-6dc8-4b86-a58c-4fdfbec96c7d": "张三",
"766de379-a8d1-4afe-aaeb-8a0142c74977": "王五",
"c9223180-3100-4b42-8e44-0b67c151982d": "",
"7632ffa0-216f-41ce-873a-ce6764d1a359": "张三丰",
"4c5918dc-b00d-49ca-b9a5-486227a1a30b": "李明"
}
findAny
作用:返回流中一个元素。如果是串行流操作则回流中的第一个元素。如果是并行流操作则返回随机一个元素。
需求一:串行流,返回一个元素。
方案:
public static void returnOne() {
List list = StreamData.nameList;
Optional any = list.stream().findAny();
if (any.isPresent()) {
System.out.println(any.get());
}
}
返回结果:
张三
需求二:并行流,返回一个元素。
方案:
public static void returnOne2() {
List list = StreamData.numList;
Optional any = list.parallelStream().findAny();
if (any.isPresent()) {
System.out.println(any.get());
}
}
返回结果:
8
findFirst
作用:返回流中第一个元素。
需求一:返回流中第一个元素。
方案:
public static void returnOne() {
List list = StreamData.nameList;
System.out.println("原始数据:"+list);
Optional any = list.stream().findFirst();
if (any.isPresent()) {
System.out.println("返回结果:"+any.get());
}
}
返回结果:
原始数据:[张三, null, null, 李四, 李四, 王五, 张三丰, 李明, 陈小东, 小张] 返回结果:张三
forEach
作用:循环集合。
需求一:循环List。
方案:
public static void forEach(){
List list=StreamData.nameList;
list.stream().forEach(name-> System.out.println(name));
}
public static void forEach2(){
List list=StreamData.nameList;
list.stream().forEach(System.out::println);
}
返回结果:
张三 null null 李四 李四 王五 张三丰 李明 陈小东 小张
需求二:循环Map。
方案:
public static void forEach3(){
Map map = StreamData.map;
map.forEach((k,v)-> System.out.println(k+"="+v));
}
返回结果:
courseName=语文 courseNo=Chinese grade=98.9 classNo=123 className=123班 stuName=张三 stuNo=123456
max/min
作用:取出流中最大/最小的元素。这里只演示max方法,min方法大家以此类推。
需求一:取出集合中最大的数。
方案:
public static void maxNum(){
List list=StreamData.numList;
System.out.println("原始数据:"+list);
Optional max = list.stream().max(
Integer::compare
);
if(max.isPresent()){
System.out.println("返回结果:"+max.get());
}
}
public static void maxNum2(){
List list=StreamData.numList;
System.out.println(list);
Optional max = list.stream().max(
(iterator,item)-> iterator.compareTo(item)
);
if(max.isPresent()){
System.out.println(max.get());
}
}
public static void maxNum3(){
//这个集合中元素都为null。
//List list=StreamData.numAllNullList;
//这个集合中部分元素为null。
List list=StreamData.numContainNullList;
System.out.println("原始数据:"+list);
boolean b = list.stream().allMatch(
num -> num == null
);
if(b){
System.out.println("集合中最大元素为:"+null);
return;
}
Optional max = list.stream().max(
(iterator,item)-> {
if(item==null){
return 1;
}
if(iterator==null){
return -1;
}
return iterator.compareTo(item);
}
);
if(max.isPresent()){
System.out.println("结果数据:"+max.get());
}
}
noneMatch
作用:检查流中所有元素是否都不匹配,都不匹配返回true,有一个匹配返回false。与allMatch相反。
需求一:检查集合中所有元素是否都不为空。每个元素都是空,则返回true,否则返回false。
方案:
public static void check() {
List list = StreamData.nameList;
System.out.println("原始数据:"+list);
boolean boo = list.stream().noneMatch(
name -> StringUtils.isNotBlank(name)
);
System.out.println("结果数据:"+boo);
}
返回结果:
原始数据:[张三, null, null, 李四, 李四, 王五, 张三丰, 李明, 陈小东, 小张] 结果数据:false
需求二:检查学生集合中是否学生都不小于18岁。都不小于18岁返回true,有一个学生小于18岁返回false。
方案:
public static void check2() {
List list = StreamData.studentInfoList;
System.out.println(list);
boolean boo = list.stream().noneMatch(
student -> student != null &&student.getAge()<18
);
System.out.println(boo);
}
原始数据:
[
{
"sex": true,
"name": "张三",
"chineseScore": 0,
"mathScore": 0,
"age": 12
},
{
"sex": true,
"name": "李四",
"chineseScore": 0,
"mathScore": 0,
"age": 13
},
{
"sex": false,
"name": "王五",
"chineseScore": 0,
"mathScore": 0,
"age": 12
},
{
"sex": true,
"name": "赵六",
"chineseScore": 0,
"mathScore": 0,
"age": 14
},
{
"sex": false,
"name": "钱七",
"chineseScore": 0,
"mathScore": 0,
"age": 12
},
{
"sex": false,
"name": "钱七",
"chineseScore": 0,
"mathScore": 0,
"age": 16
},
{
"sex": false,
"name": "钱七",
"chineseScore": 0,
"mathScore": 0,
"age": 16
},
{
"sex": false,
"chineseScore": 0,
"mathScore": 0,
"age": 16
},
{
"sex": false,
"name": "",
"chineseScore": 0,
"mathScore": 0,
"age": 19
},
{
"sex": false,
"chineseScore": 0,
"mathScore": 0,
"age": 16
}
]
返回结果:
false
reduce
作用:将流中的元素反复使用得到结果。
需求一:求集合中所有数的和。
方案:
public static void sum(){
List list=StreamData.numList;
System.out.println("原始数据:"+list);
Optional reduce = list.stream().reduce(
//accumulator表示最终结果,和item类型一样。
//item表示集合的元素
(accumulator, item) -> accumulator + item
);
if(reduce.isPresent()){
System.out.println("返回结果:"+reduce.get());
}
}
返回结果:
原始数据:[1, 2, 3, 6, 22, 8, 3, 0, 48] 返回结果:93
需求二:求所有学生的年龄之和。
方案:
public static void sum2(){
List list=StreamData.studentInfoList;
JSONArray array = JSONArray.parseArray(JSON.toJSONString(list));
System.out.println(array);
Optional reduce = list.stream().reduce(
//accumulator表示最终结果,和item类型一样。
//item表示集合的元素
(accumulator,item) -> {
accumulator.setAge(accumulator.getAge()+item.getAge());
return accumulator;
}
);
if(reduce.isPresent()){
System.out.println("年龄总和:"+reduce.get().getAge());
}
}
原始数据:
[
{
"sex": true,
"name": "张三",
"chineseScore": 0,
"mathScore": 0,
"age": 12
},
{
"sex": true,
"name": "李四",
"chineseScore": 0,
"mathScore": 0,
"age": 13
},
{
"sex": false,
"name": "王五",
"chineseScore": 0,
"mathScore": 0,
"age": 12
},
{
"sex": true,
"name": "赵六",
"chineseScore": 0,
"mathScore": 0,
"age": 14
},
{
"sex": false,
"name": "钱七",
"chineseScore": 0,
"mathScore": 0,
"age": 12
},
{
"sex": false,
"name": "钱七",
"chineseScore": 0,
"mathScore": 0,
"age": 16
},
{
"sex": false,
"name": "钱七",
"chineseScore": 0,
"mathScore": 0,
"age": 16
},
{
"sex": false,
"chineseScore": 0,
"mathScore": 0,
"age": 16
},
{
"sex": false,
"name": "",
"chineseScore": 0,
"mathScore": 0,
"age": 19
},
{
"sex": false,
"chineseScore": 0,
"mathScore": 0,
"age": 16
}
]
返回结果:
年龄总和:146
Collectors的方法
averaging
作用:求平均数。
需求一:求平均数。
方案:
public static void averaging() {
List list = StreamData.numList;
Double avg = list.stream().collect(
Collectors.averagingInt(a->a)
);
System.out.println(avg);
}
public static void averaging2() {
List list = StreamData.numDoubleList;
Double avg = list.stream().collect(
Collectors.averagingDouble(a->a)
);
System.out.println(avg);
}
collectingAndThen
作用:先对数据进行处理,处理之后再对各个分量进行处理,我个人觉得该方法和mysql的窗口函数极为相似。
需求一:求平均值,将返回平均值*10。
方案:
public static void collectingAndThen() {
List list = StreamData.numList;
Double tenAvg = list.stream().collect(
Collectors.collectingAndThen(
//第一部分
Collectors.averagingLong(num -> {
return num;
}
),
//第二部分(avgNum是上一个步骤的值。)
avgNum -> {
return avgNum * 10;
}
)
);
System.out.println(tenAvg);
}
需求二:求出集合中小于10的数,将小于10的数加10。
方案:
public static void collectingAndThen2() {
List list = StreamData.numList;
List> ltTenList = list.stream().collect(
Collectors.collectingAndThen(
//第一部分(将大于等于10和小于10的数分割成两个集合。)
Collectors.partitioningBy(
num -> num >= 10
),
//第二部分
numMap -> {
if (numMap.get(false) != null && numMap.get(false).size() > 0) {
List falseList = numMap.get(false).stream().map(
num -> num != null ? num + 10 : 10
).collect(Collectors.toList());
return falseList;
}
return new ArrayList<>();
}
)
);
System.out.println(ltTenList);
}
需求三:把相同班级的学生统计在一起,计算每个学生的平均成绩。
需求四:把相同班级的学生统计在一起,计算每个学生的各科目的成绩。大于等于60合格,小于60分不合格。
方案:这两个需求稍微复杂一点,且用到了groupingBy方法,大家可以在本篇博客中的groupingBy目录中去找这两个需求的解答方案,这里不赘述。
countIng
作用:统计元素数量。
需求一:统计元素数量。
方案:
public static void countIng(){
List list=StreamData.numList;
System.out.println("初始数据:"+list);
Long count = list.stream().collect(
Collectors.counting()
);
System.out.println("元素数量:"+count);
}
结果数据:
初始数据:[1, 2, 3, 6, 22, 8, 3, 0, 48] 元素数量:9
需求二:统计全班考试成绩超过90分的成绩数量。
方案:
public static void countIng2(){
List
原始数据:
[
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 98.9,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 91.1,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 92,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 100,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 98.5,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 89,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 88.5,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 90,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 95,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 99.5,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 81.5,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 80,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
}
]
返回结果:
结果数据:7
groupingBy
作用:按照指定的规则对数据进行分组。
需求一:把相同班级的学生分数记录统计在一起。
方案:
public static void group() {
List
原始数据:
[
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 98.9,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 91.1,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 92,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 100,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 98.5,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 89,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 88.5,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 90,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 95,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 99.5,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 81.5,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 80,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
}
]
返回结果:
{
"123": [
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 98.9,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 91.1,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 92,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 100,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 98.5,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 89,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
}
],
"124": [
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 88.5,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 90,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 95,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 99.5,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 81.5,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 80,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
}
]
}
需求二:把相同班级的学生统计在一起,只返回学号和姓名。
方案:
public static void group2() {
List
原始数据:
[
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 98.9,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 91.1,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 92,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 100,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 98.5,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 89,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 88.5,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 90,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 95,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 99.5,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 81.5,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 80,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
}
]
返回结果:
{
"123": [
{
"stuName": "张三",
"stuNo": "123456"
},
{
"stuName": "李四",
"stuNo": "123457"
}
],
"124": [
{
"stuName": "王五",
"stuNo": "123458"
},
{
"stuName": "赵六",
"stuNo": "123459"
}
]
}
需求三:求出每个班级的平均成绩。
方案:
public static void group3() {
List
原始数据:
[
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 98.9,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 91.1,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 92,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 100,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 98.5,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 89,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 88.5,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 90,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 95,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 99.5,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 81.5,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 80,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
}
]
返回结果:
{
"123": 94.91666666666667,
"124": 89.08333333333333
}
需求四:把相同班级的学生统计在一起,且学生以学号分组统计成绩。
方案:
public static void group4() {
List
原始数据:
[
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 98.9,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 91.1,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 92,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 100,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 98.5,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 89,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 88.5,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 90,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 95,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 99.5,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 81.5,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 80,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
}
]
返回结果:
{
"123": {
"123456": [
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 98.9,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 91.1,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 92,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
}
],
"123457": [
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 100,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 98.5,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 89,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
}
]
},
"124": {
"123458": [
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 88.5,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 90,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 95,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
}
],
"123459": [
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 99.5,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 81.5,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 80,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
}
]
}
}
需求五:把相同班级的学生统计在一起,计算每个学生的平均成绩。
方案:
public static void group5() {
List
原始数据:
[
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 98.9,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 91.1,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 92,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 100,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 98.5,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 89,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 88.5,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 90,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 95,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 99.5,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 81.5,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 80,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
}
]
返回结果:
{
"123": {
"123456": 94,
"123457": 95.83333333333333
},
"124": {
"123458": 91.16666666666667,
"123459": 87
}
}
需求六:把相同班级的学生统计在一起,计算每个学生的各科目的成绩。大于等于60合格,小于60分不合格。
方案:
public static void group6() {
List
原始数据:
[
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 98.9,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 91.1,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 92,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 100,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 98.5,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 89,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 88.5,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 90,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 95,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 99.5,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 81.5,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 80,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
}
]
返回结果:
{
"123": {
"123457_李四": {
"不合格": [ ],
"合格": [
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 100,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 98.5,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 89,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
}
]
},
"123456_张三": {
"不合格": [ ],
"合格": [
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 98.9,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 91.1,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 92,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
}
]
}
},
"124": {
"123458_王五": {
"不合格": [ ],
"合格": [
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 88.5,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 90,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 95,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
}
]
},
"123459_赵六": {
"不合格": [ ],
"合格": [
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 99.5,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 81.5,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 80,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
}
]
}
}
}
joining
作用:按照指定的格式拼接数据。
需求一:拼接流中的所有字符串。
方案:
public static void joining() {
List list = StreamData.animalList;
System.out.println("原始数据:"+list);
String str = list.stream().collect(
Collectors.joining()
);
System.out.println("返回结果:"+str);
}
返回结果:
原始数据:[猫, 狗, 鸡, 鸭] 返回结果:猫狗鸡鸭
需求二:拼接流中的所有字符串,用逗号分开。
方案:
public static void joining2() {
List list = StreamData.animalList;
System.out.println("原始数据:"+list);
String str = list.stream().collect(
Collectors.joining(",")
);
System.out.println("返回结果:"+str);
}
返回结果:
原始数据:[猫, 狗, 鸡, 鸭] 返回结果:猫,狗,鸡,鸭
需求三:拼接流中的所有字符串,用逗号分开,用大括号包裹。
方案:
public static void joining3() {
List list = StreamData.animalList;
System.out.println("原始数据:"+list);
String str = list.stream().collect(
Collectors.joining(",","{","}")
);
System.out.println("返回结果:"+str);
}
返回结果:
原始数据:[猫, 狗, 鸡, 鸭]
返回结果:{猫,狗,鸡,鸭}
mapping
作用:抽取需要的属性,定义返回格式。
需求一:求所有参加考试的学生的学号。
方案:
public static void mapping() {
List
原始数据:
[
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 98.9,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 91.1,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 92,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 100,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 98.5,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 89,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 88.5,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 90,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 95,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 99.5,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 81.5,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 80,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
}
]
返回结果:
[123459, 123457, 123458, 123456]
需求二:求所有参加考试的学生的学号和姓名。
方案:
public static void mapping2() {
List
原始数据:
[
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 98.9,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 91.1,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 92,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 100,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 98.5,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 89,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 88.5,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 90,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 95,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 99.5,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 81.5,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 80,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
}
]
返回结果:
[
{
"stuName": "张三",
"stuNo": "123456"
},
{
"stuName": "王五",
"stuNo": "123458"
},
{
"stuName": "李四",
"stuNo": "123457"
},
{
"stuName": "赵六",
"stuNo": "123459"
}
]
需求三:把相同班级的学生分数记录统计在一起,只返回学号和姓名。
方案:
public static void group2() {
List
原始数据:
[
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 98.9,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 91.1,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 92,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 100,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 98.5,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 89,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 88.5,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 90,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 95,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 99.5,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 81.5,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 80,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
}
]
返回结果:
{
"123": [
{
"stuName": "张三",
"stuNo": "123456"
},
{
"stuName": "李四",
"stuNo": "123457"
}
],
"124": [
{
"stuName": "王五",
"stuNo": "123458"
},
{
"stuName": "赵六",
"stuNo": "123459"
}
]
}
maxBy/minBy
作用:求最大/最小记录。这里只演示maxBy方法,minBy方法大家以此类推。
需求一:求分数最高的一条记录。
方案:
public static void maxBy() {
List
原始数据:
[
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 98.9,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 91.1,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 92,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 100,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 98.5,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 89,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 88.5,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 90,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 95,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 99.5,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 81.5,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 80,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
}
]
返回结果:
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 100,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
}
partitioningBy
作用:按照指定的规则对数据进行分组。
需求一:将集合中大于10的数分为一组,将小于或等于10的数分为一组。
方案:
public static void partitioning(){
List list=StreamData.numList;
System.out.println(list);
Map> map = list.stream().collect(
Collectors.partitioningBy(num -> num > 10)
);
JSONObject json = JSONObject.parseObject(JSON.toJSONString(map));
System.out.println(json);
}
原始数据:
[1, 2, 3, 6, 22, 8, 3, 0, 48]
返回结果:
{
"false": [
1,
2,
3,
6,
8,
3,
0
],
"true": [
22,
48
]
}
需求二:将学生大于或等于18岁的分为一组,反之放到另一组。
方案:
public static void partitioning2(){
List list=StreamData.studentInfoList;
JSONArray array = JSONArray.parseArray(JSON.toJSONString(list));
System.out.println(array);
Map> map = list.stream().collect(
Collectors.partitioningBy(student -> student != null && student.getAge() >= 18)
);
JSONObject json = JSONObject.parseObject(JSON.toJSONString(map));
System.out.println(json);
}
原始数据:
[
{
"sex": true,
"name": "张三",
"chineseScore": 0,
"mathScore": 0,
"age": 12
},
{
"sex": true,
"name": "李四",
"chineseScore": 0,
"mathScore": 0,
"age": 13
},
{
"sex": false,
"name": "王五",
"chineseScore": 0,
"mathScore": 0,
"age": 12
},
{
"sex": true,
"name": "赵六",
"chineseScore": 0,
"mathScore": 0,
"age": 14
},
{
"sex": false,
"name": "钱七",
"chineseScore": 0,
"mathScore": 0,
"age": 12
},
{
"sex": false,
"name": "钱七",
"chineseScore": 0,
"mathScore": 0,
"age": 16
},
{
"sex": false,
"name": "钱七",
"chineseScore": 0,
"mathScore": 0,
"age": 16
},
{
"sex": false,
"chineseScore": 0,
"mathScore": 0,
"age": 16
},
{
"sex": false,
"name": "",
"chineseScore": 0,
"mathScore": 0,
"age": 19
},
{
"sex": false,
"chineseScore": 0,
"mathScore": 0,
"age": 16
}
]
返回结果:
{
"false": [
{
"sex": true,
"name": "张三",
"chineseScore": 0,
"mathScore": 0,
"age": 12
},
{
"sex": true,
"name": "李四",
"chineseScore": 0,
"mathScore": 0,
"age": 13
},
{
"sex": false,
"name": "王五",
"chineseScore": 0,
"mathScore": 0,
"age": 12
},
{
"sex": true,
"name": "赵六",
"chineseScore": 0,
"mathScore": 0,
"age": 14
},
{
"sex": false,
"name": "钱七",
"chineseScore": 0,
"mathScore": 0,
"age": 12
},
{
"sex": false,
"name": "钱七",
"chineseScore": 0,
"mathScore": 0,
"age": 16
},
{
"sex": false,
"name": "钱七",
"chineseScore": 0,
"mathScore": 0,
"age": 16
},
{
"sex": false,
"chineseScore": 0,
"mathScore": 0,
"age": 16
},
{
"sex": false,
"chineseScore": 0,
"mathScore": 0,
"age": 16
}
],
"true": [
{
"sex": false,
"name": "",
"chineseScore": 0,
"mathScore": 0,
"age": 19
}
]
}
summarizing
作用:求流聚合后的数据。
需求一:求集合中的最大数,最小数,平均数,和,集合中元素的数量。
方案:
public static void summarizing() {
List list = StreamData.numList;
System.out.println("原始数据:"+list);
IntSummaryStatistics collect = list.stream().collect(
Collectors.summarizingInt(a -> a)
);
System.out.println("平均数=" + collect.getAverage());
System.out.println("元素数量=" + collect.getCount());
System.out.println("和=" + collect.getSum());
System.out.println("最大数=" + collect.getMax());
System.out.println("最小数=" + collect.getMin());
}
返回结果:
原始数据:[1, 2, 3, 6, 22, 8, 3, 0, 48] 平均数=10.333333333333334 元素数量=9 和=93 最大数=48 最小数=0
需求二:求学生的最高年龄,最低年龄,平均年龄,年龄总和,学生数量。
方案:
public static void summarizing2() {
List list = StreamData.studentInfoList;
JSONArray array = JSONArray.parseArray(JSON.toJSONString(list));
System.out.println(array);
IntSummaryStatistics collect = list.stream().collect(
Collectors.summarizingInt(stu -> stu.getAge()
)
);
System.out.println("平均年龄=" + collect.getAverage());
System.out.println("学生数量=" + collect.getCount());
System.out.println("年龄总和=" + collect.getSum());
System.out.println("最高年龄=" + collect.getMax());
System.out.println("最低年龄=" + collect.getMin());
}
原始数据:
[
{
"sex": true,
"name": "张三",
"chineseScore": 0,
"mathScore": 0,
"age": 12
},
{
"sex": true,
"name": "李四",
"chineseScore": 0,
"mathScore": 0,
"age": 13
},
{
"sex": false,
"name": "王五",
"chineseScore": 0,
"mathScore": 0,
"age": 12
},
{
"sex": true,
"name": "赵六",
"chineseScore": 0,
"mathScore": 0,
"age": 14
},
{
"sex": false,
"name": "钱七",
"chineseScore": 0,
"mathScore": 0,
"age": 12
},
{
"sex": false,
"name": "钱七",
"chineseScore": 0,
"mathScore": 0,
"age": 16
},
{
"sex": false,
"name": "钱七",
"chineseScore": 0,
"mathScore": 0,
"age": 16
},
{
"sex": false,
"chineseScore": 0,
"mathScore": 0,
"age": 16
},
{
"sex": false,
"name": "",
"chineseScore": 0,
"mathScore": 0,
"age": 19
},
{
"sex": false,
"chineseScore": 0,
"mathScore": 0,
"age": 16
}
]
返回结果:
平均年龄=14.6 学生数量=10 年龄总和=146 最高年龄=19 最低年龄=12
需求三:在学生的语文成绩大于98分的区间内,查询最高分,最低分,平均分,分数总和,符合条件分数的记录数。
方案:
public static void summarizing3() {
List> list = StreamData.studentAchievementList;
JSONArray array = JSONArray.parseArray(JSON.toJSONString(list));
System.out.println(array);
DoubleSummaryStatistics collect = list.stream().filter(
stu -> "Chinese".equals(stu.get("courseNo").toString()) && Double.parseDouble(stu.get("grade").toString()) > 98
).collect(
Collectors.summarizingDouble(
stu -> Double.parseDouble(stu.get("grade").toString())
)
);
System.out.println("平均分数=" + collect.getAverage());
System.out.println("符合条件的数量=" + collect.getCount());
System.out.println("分数总和=" + collect.getSum());
System.out.println("最高分数=" + collect.getMax());
System.out.println("最低分数=" + collect.getMin());
}
原始数据:
[
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 98.9,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 91.1,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 92,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 100,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 98.5,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 89,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 88.5,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 90,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 95,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 99.5,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 81.5,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 80,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
}
]
返回结果:
平均分数=99.46666666666665 符合条件的数量=3 分数总和=298.4 最高分数=100.0 最低分数=98.9
需求四:在学生的语文成绩大于98分的区间内,查询英语的最高分,英语的最低分,英语的平均分,英语的分数总和,符合条件分数的记录数。
方案:
public static void summarizing4() {
List> list = StreamData.studentAchievementList;
JSONArray array = JSONArray.parseArray(JSON.toJSONString(list));
System.out.println(array);
//先求出符合条件的学生。
Set set = list.stream().filter(
stu -> "Chinese".equals(stu.get("courseNo").toString()) && Double.parseDouble(stu.get("grade").toString()) > 98
).map(
stu -> stu.get("stuNo").toString()
).collect(
Collectors.toSet()
);
//根据学号求结果
DoubleSummaryStatistics collect = list.stream().filter(
stu -> "English".equals(stu.get("courseNo").toString())&&set.contains(stu.get("stuNo").toString())
).collect(
Collectors.summarizingDouble(
stu -> Double.parseDouble(stu.get("grade").toString())
)
);
System.out.println("平均分数=" + collect.getAverage());
System.out.println("符合条件的数量=" + collect.getCount());
System.out.println("分数总和=" + collect.getSum());
System.out.println("最高分数=" + collect.getMax());
System.out.println("最低分数=" + collect.getMin());
}
原始数据:
[
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 98.9,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 91.1,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 92,
"classNo": "123",
"className": "123班",
"stuName": "张三",
"stuNo": "123456"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 100,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 98.5,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 89,
"classNo": "123",
"className": "123班",
"stuName": "李四",
"stuNo": "123457"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 88.5,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 90,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 95,
"classNo": "124",
"className": "124班",
"stuName": "王五",
"stuNo": "123458"
},
{
"courseName": "语文",
"courseNo": "Chinese",
"grade": 99.5,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
},
{
"courseName": "数学",
"courseNo": "Math",
"grade": 81.5,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
},
{
"courseName": "英语",
"courseNo": "English",
"grade": 80,
"classNo": "124",
"className": "124班",
"stuName": "赵六",
"stuNo": "123459"
}
]
返回结果:
平均分数=87.0 符合条件的数量=3 分数总和=261.0 最高分数=92.0 最低分数=80.0
项目下载地址
熟练使用stream操作集合,能通过例题举一反三,合理地将案例融入到实际工作中。



