目 录
简介：lambda表达式是Java1.8新增的，在处理Java中，与集合（如：List、Set、Map等）相关的数据，应用较多（例如，筛选List中数据，给List中的数据排序等）。
1. 代替匿名内部类实现接口
1.1 未使用lambda表达式
- 代码实现
package com.javabasic.lambda;
/**
* @Description Lambda示例1
* @ClassName LambdaDemo01
* @Author yuhuofei
* @Date 2021/12/19 19:23
* @Version 1.0
*/
public class LambdaDemo01 {
//定义一个接口
interface Printer {
void printData(String string);
}
//定义一个方法
public void printSomething(String string, Printer printer) {
//用接口方法打印
printer.printData(string);
}
public static void main(String[] args) {
LambdaDemo01 lambdaDemo01 = new LambdaDemo01();
String string = "HelloWorld !";
//匿名实现类实现接口中的方法
Printer printer = new Printer() {
@Override
public void printData(String string) {
System.out.println("要输出的数据是：" + string);
}
};
//调用方法
lambdaDemo01.printSomething(string, printer);
}
}
- 运行结果
1.2 使用lambda表达式
- 代码实现
package com.javabasic.lambda;
/**
* @Description Lambda示例1
* @ClassName LambdaDemo01
* @Author yuhuofei
* @Date 2021/12/19 19:23
* @Version 1.0
*/
public class LambdaDemo01 {
//定义一个接口
interface Printer {
void printData(String string);
}
//定义一个方法
public void printSomething(String string, Printer printer) {
//用接口方法打印
printer.printData(string);
}
public static void main(String[] args) {
LambdaDemo01 lambdaDemo01 = new LambdaDemo01();
String string = "使用lambda ！";
/*
//常规用法
Printer printer = (String data) -> {
System.out.println("要输出的数据是：" + data);
};
*/
/*
//简化用法一：（1）可以省略参数类型（2）当只有一个参数时，可以省略参数的小括号
Printer printer = data -> {
System.out.println("要输出的数据是：" + data);
};
*/
//简化用法二：当函数体只有一行时，可以省略掉花括号
Printer printer = data -> System.out.println("要输出的数据是：" + data);
//调用方法
lambdaDemo01.printSomething(string, printer);
}
}
- 运行结果
2. Stream代替for循环
目标：将列表中所有以c开头的字符串筛选出来，并转换成大写，然后把这些大写的字符串组成一个新的列表进行排序，返回排序后的数组。
2.1 不使用lambda表达式
使用循环语句处理
2.2 使用lambda表达式
- 代码实现
package com.javabasic.lambda;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* @Description Streams代替for循环
* @ClassName LambdaDemo02
* @Author yuhuofei
* @Date 2021/12/19 21:57
* @Version 1.0
*/
public class LambdaDemo02 {
public static void main(String[] args) {
List<String> list = Arrays.asList("kobe","james","curry","cat");
List<String> sortedList = list.stream() //将列表List<String> 转换成流
.filter(p -> p.startsWith("c")) //使用filter对流中的数据进行过滤，过滤规则是以"c"开头的字符串
.map(String::toUpperCase) //将过滤出来的字符串都转换成大写
.sorted() //将字符串进行排序
.collect(Collectors.toList()); //将流转换成列表List<String>
System.out.println("筛选结果是："+sortedList);
}
}
3. Stream中filter方法的使用
filter方法主要是用于根据条件，对数据进行过滤和筛选，常见的三种筛选条件分别是and(&&)、or(||)、negate(!)，下面是使用的示例。
3.1 利用&&、||、!做过滤
- 新建一个Student类
package com.javabasic.entity;
import java.io.Serializable;
/**
* @Description 学生实体类
* @ClassName Student
* @Author yuhuofei
* @Date 2021/12/26 12:33
* @Version 1.0
*/
public class Student implements Serializable {
private final static long serialVersionUID = 1L;
private String name;
private String sex;
private int age;
private int id;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public Student(String name, String sex, int age, int id) {
this.name = name;
this.sex = sex;
this.age = age;
this.id = id;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", sex='" + sex + '\'' +
", age=" + age +
", id=" + id +
'}';
}
}
- 新建一个StreamFilterPredicate类，用于演示
package com.javabasic.lambda;
import com.javabasic.entity.Student;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* @Description
* @ClassName StreamFilterPredicate
* @Author yuhuofei
* @Date 2021/12/26 12:37
* @Version 1.0
*/
public class StreamFilterPredicate {
public static void main(String[] args) {
//初始化数据
Student student1 = new Student("zhangsan", "M", 20, 1);
Student student2 = new Student("lisi", "M", 20, 2);
Student student3 = new Student("wangwu", "M", 19, 3);
Student student4 = new Student("xiaohong", "F", 18, 4);
Student student5 = new Student("xiaohua", "F", 20, 5);
Student student6 = new Student("qiuya", "F", 18, 6);
Student student7 = new Student("xialuo", "M", 20, 7);
Student student8 = new Student("yuanhua", "M", 19, 8);
Student student9 = new Student("madongmei", "F", 18, 9);
//将数据放入列表中
List<Student> studentList = Arrays.asList(student1, student2, student3, student4, student5, student6, student7, student8, student9);
//过滤筛选，年龄等于20且性别是M的同学
List<Student> newStudentList = studentList.stream().filter(p -> p.getAge() == 20 && p.getSex().equals("M")).collect(Collectors.toList());
//过滤筛选，年龄等于20或者性别是M的同学
List<Student> newStudentList1 = studentList.stream().filter(p -> p.getAge() == 20 || p.getSex().equals("M")).collect(Collectors.toList());
//过滤筛选，年龄不等于20且性别不是M的同学
List<Student> newStudentList2 = studentList.stream().filter(p -> !(p.getAge() == 20 || p.getSex().equals("M"))).collect(Collectors.toList());
System.out.println("&&作用下的筛选结果是：" + newStudentList);
System.out.println("||作用下的筛选结果是：" + newStudentList1);
System.out.println("！作用下的筛选结果是：" + newStudentList2);
}
}
- 运行结果如下
3.2 使用and、or、negate做过滤
- 在Student类中做出修改，如下
public static Predicate<Student> ageEquals20 = p -> p.getAge() == 20;
package com.javabasic.entity;
import java.io.Serializable;
import java.util.function.Predicate;
/**
* @Description 学生实体类
* @ClassName Student
* @Author yuhuofei
* @Date 2021/12/26 12:33
* @Version 1.0
*/
public class Student implements Serializable {
private final static long serialVersionUID = 1L;
private String name;
private String sex;
private int age;
private int id;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public Student(String name, String sex, int age, int id) {
this.name = name;
this.sex = sex;
this.age = age;
this.id = id;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", sex='" + sex + '\'' +
", age=" + age +
", id=" + id +
'}';
}
public static Predicate<Student> ageEquals20 = p -> p.getAge() == 20;
public static Predicate<Student> getSexForM = p -> p.getSex().equals("M");
}
- StreamFilterPredicate类也做出修改，如下
package com.javabasic.lambda;
import com.javabasic.entity.Student;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* @Description
* @ClassName StreamFilterPredicate
* @Author yuhuofei
* @Date 2021/12/26 12:37
* @Version 1.0
*/
public class StreamFilterPredicate {
public static void main(String[] args) {
//初始化数据
Student student1 = new Student("zhangsan", "M", 20, 1);
Student student2 = new Student("lisi", "M", 20, 2);
Student student3 = new Student("wangwu", "M", 19, 3);
Student student4 = new Student("xiaohong", "F", 18, 4);
Student student5 = new Student("xiaohua", "F", 20, 5);
Student student6 = new Student("qiuya", "F", 18, 6);
Student student7 = new Student("xialuo", "M", 20, 7);
Student student8 = new Student("yuanhua", "M", 19, 8);
Student student9 = new Student("madongmei", "F", 18, 9);
//将数据放入列表中
List<Student> studentList = Arrays.asList(student1, student2, student3, student4, student5, student6, student7, student8, student9);
//过滤筛选，年龄等于20且性别是M的同学
// List<Student> newStudentList = studentList.stream().filter(p -> p.getAge() == 20 && p.getSex().equals("M")).collect(Collectors.toList());
List<Student> newStudentList = studentList.stream().filter(Student.ageEquals20.and(Student.getSexForM)).collect(Collectors.toList());
//过滤筛选，年龄等于20或者性别是M的同学
// List<Student> newStudentList1 = studentList.stream().filter(p -> p.getAge() == 20 || p.getSex().equals("M")).collect(Collectors.toList());
List<Student> newStudentList1 = studentList.stream().filter(Student.ageEquals20.or(Student.getSexForM)).collect(Collectors.toList());
//过滤筛选，年龄不等于20且性别不是M的同学
// List<Student> newStudentList2 = studentList.stream().filter(p -> !(p.getAge() == 20 || p.getSex().equals("M"))).collect(Collectors.toList());
List<Student> newStudentList2 = studentList.stream().filter(Student.ageEquals20.or(Student.getSexForM).negate()).collect(Collectors.toList());
System.out.println("and作用下的筛选结果是：" + newStudentList);
System.out.println("or作用下的筛选结果是：" + newStudentList1);
System.out.println("negate作用下的筛选结果是：" + newStudentList2);
}
}
- 运行得到的结果
由此可见，两种方式得到的结果，都是一样的。
4. Stream中map方法的使用
4.1 简单的数据转换
将字符串转换成大写
package com.javabasic.lambda;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* @Description
* @ClassName StreamMap1
* @Author yuhuofei
* @Date 2021/12/26 14:37
* @Version 1.0
*/
public class StreamMap1 {
public static void main(String[] args) {
List<String> list = Arrays.asList("Apple","Banana","Pink","Lion");
//使用常规方式，将list中的元素全部转换成大写
List<String> listUpper = new ArrayList<>();
for (String s: list){
listUpper.add(s.toUpperCase());
}
System.out.println("常规方式进行数据转换的结果："+listUpper);
//使用管道流
// List<String> list1 =list.stream().map(s -> s.toUpperCase()).collect(Collectors.toList());
List<String> list1 =list.stream().map(String::toUpperCase).collect(Collectors.toList());
System.out.println("使用管道流进行数据转换的结果："+list1);
//获取长度并输出
list.stream().mapToInt(String::length).forEach(System.out::println);
}
}
4.2 map中多语句数据处理
- Student类（沿用前面的）
package com.javabasic.entity;
import java.io.Serializable;
import java.util.function.Predicate;
/**
* @Description 学生实体类
* @ClassName Student
* @Author yuhuofei
* @Date 2021/12/26 12:33
* @Version 1.0
*/
public class Student implements Serializable {
private final static long serialVersionUID = 1L;
private String name;
private String sex;
private int age;
private int id;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public Student(String name, String sex, int age, int id) {
this.name = name;
this.sex = sex;
this.age = age;
this.id = id;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", sex='" + sex + '\'' +
", age=" + age +
", id=" + id +
'}';
}
public static Predicate<Student> ageEquals20 = p -> p.getAge() == 20;
public static Predicate<Student> getSexForM = p -> p.getSex().equals("M");
}
- 新建一个StreamMap2类，做实现
package com.javabasic.lambda;
import com.javabasic.entity.Student;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* @Description
* @ClassName SreamMap2
* @Author yuhuofei
* @Date 2021/12/26 17:05
* @Version 1.0
*/
public class StreamMap2 {
public static void main(String[] args) {
//初始化数据
Student student1 = new Student("zhangsan", "M", 20, 1);
Student student2 = new Student("lisi", "M", 20, 2);
Student student3 = new Student("wangwu", "M", 19, 3);
Student student4 = new Student("xiaohong", "F", 18, 4);
Student student5 = new Student("xiaohua", "F", 20, 5);
Student student6 = new Student("qiuya", "F", 18, 6);
Student student7 = new Student("xialuo", "M", 20, 7);
Student student8 = new Student("yuanhua", "M", 19, 8);
Student student9 = new Student("madongmei", "F", 18, 9);
//将数据放入列表中
List<Student> studentList = Arrays.asList(student1, student2, student3, student4, student5, student6, student7, student8, student9);
//利用管道流进行处理，对所有元素的年龄都加1，性别替换成Male或者Female
List<Student> newList = studentList.stream().map(p -> {
p.setAge(p.getAge() + 1);
p.setSex(p.getSex().equals("M") ? "Male" : "Female");
return p;
}).collect(Collectors.toList());
System.out.println("处理后的列表是：" + newList);
}
}
4.3 利用flatmap处理二维数组数据
- 代码如下所示
package com.javabasic.lambda;
import java.util.Arrays;
import java.util.List;
/**
* @Description 将列表中的字母逐个取出来
* @ClassName StreamMap3
* @Author yuhuofei
* @Date 2021/12/26 20:47
* @Version 1.0
*/
public class StreamMap3 {
public static void main(String[] args) {
List<String> list = Arrays.asList("Hello", "World");
//利用map方法，得到的结果是两个字符串，不符合要求
list.stream().map(p -> p.split("")).forEach(System.out::println);
//利用flatMap方法
list.stream().flatMap(p -> Arrays.stream(p.split(""))).forEach(System.out::println);
}
}
- 结果如下所示
5. limit、skip、distinct、sorted方法在Stream中的使用
5.1 limit、skip、distinct、sorted方法的使用
package com.javabasic.lambda;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
* @Description
* @ClassName StreamState
* @Author yuhuofei
* @Date 2021/12/26 22:20
* @Version 1.0
*/
public class StreamState {
public static void main(String[] args) {
//使用limit，限制数量
List<String> limitDemo = Arrays.asList("Monkey", "Lion", "Giraffe", "Lemur");
List<String> limitN = limitDemo.stream().limit(2).collect(Collectors.toList());
System.out.println("使用limit得到的结果：" + limitN);
//使用skip，跳过
List<String> skipN = Stream.of("Monkey", "Lion", "Giraffe", "Lemur").skip(2).collect(Collectors.toList());
System.out.println("使用skip得到的结果：" + skipN);
//使用distinct，去重
List<String> unique = Stream.of("Monkey", "Lion", "Giraffe", "Lemur", "Lion", "Monkey").distinct().collect(Collectors.toList());
System.out.println("使用distinct得到的结果：" + unique);
//使用sorted，排序
List<String> order = Stream.of("Monkey", "Lion", "Giraffe", "Lemur").sorted().collect(Collectors.toList());
System.out.println("使用sorted得到的结果：" + order);
}
}
5.2 并行操作
在Stream中，parallel()方法表示并行操作，而一般没有特别指明，通常我们用的都是串行操作（即执行sequential()方法）。
一般是执行无状态的操作，才用并行，因为并行是不能保证顺序的。
以下是一些无状态和有状态操作的区分：
6. 集合排序
- 沿用前面的Student类
package com.javabasic.entity;
import java.io.Serializable;
import java.util.function.Predicate;
/**
* @Description 学生实体类
* @ClassName Student
* @Author yuhuofei
* @Date 2021/12/26 12:33
* @Version 1.0
*/
public class Student implements Serializable {
private final static long serialVersionUID = 1L;
private String name;
private String sex;
private int age;
private int id;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public Student(String name, String sex, int age, int id) {
this.name = name;
this.sex = sex;
this.age = age;
this.id = id;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", sex='" + sex + '\'' +
", age=" + age +
", id=" + id +
'}';
}
public static Predicate<Student> ageEquals20 = p -> p.getAge() == 20;
public static Predicate<Student> getSexForM = p -> p.getSex().equals("M");
}
- 新建一个SortList类
package com.javabasic.lambda;
import com.javabasic.entity.Student;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
/**
* @Description 集合排序
* @ClassName SortList
* @Author yuhuofei
* @Date 2021/12/27 0:10
* @Version 1.0
*/
public class SortList {
public static void main(String[] args) {
//初始化数据
Student student1 = new Student("zhangsan", "M", 20, 1);
Student student2 = new Student("lisi", "M", 20, 2);
Student student3 = new Student("wangwu", "M", 19, 3);
Student student4 = new Student("xiaohong", "F", 18, 4);
Student student5 = new Student("xiaohua", "F", 20, 5);
Student student6 = new Student("qiuya", "F", 18, 6);
Student student7 = new Student("xialuo", "M", 20, 7);
Student student8 = new Student("yuanhua", "M", 19, 8);
Student student9 = new Student("madongmei", "F", 18, 9);
//将数据放入列表中
List<Student> studentList = Arrays.asList(student1, student2, student3, student4, student5, student6, student7, student8, student9);
//进行排序，(1)先按性别排序（2）然后按年龄排序（3）最后将前面的进行倒序排序
studentList.sort(
Comparator.comparing(Student::getSex)
.thenComparing(Student::getAge)
.reversed()
);
//输出结果
studentList.forEach(System.out::println);
}
}
7. 函数式接口
最典型的函数式接口，Comparator接口
7.1 函数式接口的特点
- 接口有且仅有一个抽象方法，如Comparator接口中的compare方法
- 允许定义静态非抽象方法
- 允许定义默认default非抽象方法
- 允许java.lang.Object中的public方法，如Comparator接口中的equals方法
- FunctionInterface注解不是必须的
7.2 接口中default关键字的作用
-
问题：当一个接口有很多的实现类时，修改这个接口就变成了一个非常麻烦的事情，需要修改这个接口的所有实现类。
-
default方法可以有自己的默认实现，即有方法体。
-
接口实现类可以不去实现default方法，并且可以使用default方法。
7.3 自定义函数式接口中的实现方法
重写Comparator接口中的抽象方法compare()
- 代码如下
package com.javabasic.lambda;
import com.javabasic.entity.Student;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
/**
* @Description 集合排序
* @ClassName SortList
* @Author yuhuofei
* @Date 2021/12/27 0:10
* @Version 1.0
*/
public class SortList {
public static void main(String[] args) {
//初始化数据
Student student1 = new Student("zhangsan", "M", 20, 1);
Student student2 = new Student("lisi", "M", 20, 2);
Student student3 = new Student("wangwu", "M", 19, 3);
Student student4 = new Student("xiaohong", "F", 18, 4);
Student student5 = new Student("xiaohua", "F", 20, 5);
Student student6 = new Student("qiuya", "F", 18, 6);
Student student7 = new Student("xialuo", "M", 20, 7);
Student student8 = new Student("yuanhua", "M", 19, 8);
Student student9 = new Student("madongmei", "F", 18, 9);
//将数据放入列表中
List<Student> studentList = Arrays.asList(student1, student2, student3, student4, student5, student6, student7, student8, student9);
//进行排序，(1)先按性别排序（2）然后按年龄排序（3）最后将前面的进行倒序排序
studentList.sort(
Comparator.comparing(Student::getSex)
.thenComparing(Student::getAge)
.reversed()
);
//输出结果
studentList.forEach(System.out::println);
System.out.println("==================分隔线=================");
//自定义实现compare方法，按年龄大小进行排序
studentList.sort((o1, o2) -> {
if (o1.getAge() == o2.getAge()) {
return 0;
}
return o1.getAge() - o2.getAge() > 0 ? -1 : 1;
});
//输出结果
studentList.forEach(System.out::println);
}
}
- 运行结果
8. Stream查找与匹配元素
实际开发中，常见的需求点：
- 是否包含某一个“匹配规则”的元素
- 是否所有的元素都符合某一个“匹配规则”
- 是否所有的元素都不符合某一个“匹配规则”
- 查找第一个符合“匹配规则”的元素
- 查找任意一个符合“匹配规则”的元素
代码示例如下：
package com.javabasic.lambda;
import com.javabasic.entity.Student;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
/**
* @Description
* @ClassName StreamUse
* @Author yuhuofei
* @Date 2021/12/27 1:25
* @Version 1.0
*/
public class StreamUse {
public static void main(String[] args) {
//初始化数据
Student student1 = new Student("zhangsan", "M", 20, 1);
Student student2 = new Student("lisi", "M", 20, 2);
Student student3 = new Student("wangwu", "M", 19, 3);
Student student4 = new Student("xiaohong", "F", 18, 4);
Student student5 = new Student("xiaohua", "F", 20, 5);
Student student6 = new Student("qiuya", "F", 18, 6);
Student student7 = new Student("xialuo", "M", 20, 7);
Student student8 = new Student("yuanhua", "M", 19, 8);
Student student9 = new Student("madongmei", "F", 18, 9);
//将数据放入列表中
List<Student> studentList = Arrays.asList(student1, student2, student3, student4, student5, student6, student7, student8, student9);
//（1）是否包含某一个“匹配规则”的元素 ----是否包含年龄大于19岁的学生
boolean isExistAgeThan19 = studentList.stream().anyMatch(e -> e.getAge() > 19);
System.out.println("是否包含年龄大于19岁的元素：" + isExistAgeThan19);
//（2）是否所有的元素都符合某一个“匹配规则” ----是否所有学生都大于16岁
boolean isExistAgeThan16 = studentList.stream().allMatch(e -> e.getAge() > 16);
System.out.println("是否所有元素都大于16岁：" + isExistAgeThan16);
//（3）是否所有的元素都不符合某一个“匹配规则” ----是否所有学生都不小于18岁
boolean isExistAgeThan18 = studentList.stream().noneMatch((e -> e.getAge() < 18));
System.out.println("是否所有元素都不小于18岁：" + isExistAgeThan18);
//（4）查找第一个符合“匹配规则”的元素 ----查找列表中第一个19岁的学生
Optional<Student> student = studentList.stream().filter(p -> p.getAge() == 19).findFirst();
System.out.println("查找列表中第一个19岁的学生：" + student.get());
//（5）查找任意一个符合“匹配规则”的元素 ----查找列表中任意一个20岁的学生
Optional<Student> anyStudent = studentList.stream().filter(p -> p.getAge() == 18).findAny();
System.out.println("查找列表中任意一个18岁的学生：" + anyStudent.get());
}
}
执行结果如下
9. Stream中的归约与收集
说明：示例中的Student类，沿用前面创建的。
1、代码示例如下：
package com.javabasic.lambda;
import com.javabasic.entity.Student;
import java.util.Arrays;
import java.util.List;
/**
* @Description 归约
* @ClassName ReduceDemo
* @Author yuhuofei
* @Date 2021/12/29 23:44
* @Version 1.0
*/
public class ReduceDemo {
public static void main(String[] args) {
//示例1
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
Integer total = numbers.stream().reduce(0, (s, e) -> s + e);
System.out.println("使用lambda表达式得到的和是：" + total);
total = numbers.stream().reduce(0, Integer::sum);
System.out.println("调用Integer自带的方法得到的和：" + total);
//示例2
List<String> letters = Arrays.asList("a", "b", "c", "s", "e", "t");
String s = letters.stream().reduce("", String::concat);
System.out.println("得到的字符串是：" + s);
//示例3
Student student1 = new Student("zhangsan", "M", 20, 1);
Student student2 = new Student("lisi", "M", 20, 2);
Student student3 = new Student("wangwu", "M", 19, 3);
Student student4 = new Student("xiaohong", "F", 18, 4);
Student student5 = new Student("xiaohua", "F", 20, 5);
Student student6 = new Student("qiuya", "F", 18, 6);
Student student7 = new Student("xialuo", "M", 20, 7);
Student student8 = new Student("yuanhua", "M", 19, 8);
Student student9 = new Student("madongmei", "F", 18, 9);
List<Student> studentList = Arrays.asList(student1, student2, student3, student4, student5, student6, student7, student8, student9);
//示例3：实现方式一
Integer sumAge = studentList.stream()
.map(Student::getAge) //使用map，将流中的Student对象都转换成age
.reduce(0, Integer::sum); //对所有age求和
System.out.println("所有学生的年龄和：" + sumAge);
//示例3：实现方式二
Integer paraSumAge = studentList.parallelStream() //并行方式，提高执行效率
.map(Student::getAge) //使用map，将流中的Student对象都转换成age
.reduce(0, Integer::sum, Integer::sum); //三个参数含义：初始值，累加器，合并器
System.out.println("并行方式求所有学生的年龄和：" + paraSumAge);
//示例3：实现方式三
Integer age = studentList.stream().reduce(0, (sum, student) -> sum + student.getAge(), Integer::sum);
System.out.println("直接使用reduce方法求所有学生的年龄和：" + age);
}
}
2、代码运行结果
扫一扫
1629
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
