目录
一、Lambda表达式
Lambda 是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。
Lambda表达式的本质 : 作为函数式接口的实例
举例 :
(o1, o2) -> Integer.compare(o1, o2); 格式 :
-> : lambda操作符 或 箭头操作符
-> 左边 : lambda形参列表(其实就是接口中的抽象方法的形参列表)
-> 右边 : lambda体(其实就是重写的抽象方法的方法体)1. lambda表达式的使用情况
语法格式一 : 无参、无返回值。
/*
语法格式一 : 无参、无返回值
*/
@Test
public void test01(){
Runnable r1 = new Runnable() {
@Override
public void run() {
System.out.println("我爱北京天安门");
}
};
r1.run();
System.out.println("-----------------------------------------");
//使用lambda表达式
Runnable r2 = () -> System.out.println("我爱北京故宫");
r2.run();
}语法格式二 : Lambda 需要一个参数，但是没有返回值。
/*
语法格式二：Lambda 需要一个参数，但是没有返回值。
*/
@Test
public void test03(){
Consumer<String> cons = new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
};
cons.accept("Hello world");
System.out.println("****************************");
Consumer<String> cons2 = (String s) -> {
System.out.println(s);
};
cons2.accept("Hello world");
}语法格式三 : 数据类型可以省略，因为可由编译器推断得出，称为“类型推断”
/*
语法格式三：数据类型可以省略，因为可由编译器推断得出，称为“类型推断”
*/
@Test
public void test04(){
Consumer<String> cons2 = (String s) -> {
System.out.println(s);
};
cons2.accept("Hello world");
//类型推断
Consumer<String> cons3 = (s) -> {
System.out.println(s);
};
cons3.accept("Hello world");
}语法格式四 : Lambda 若只需要一个参数时，参数的小括号可以省略
/*
语法格式四 : Lambda 若只需要一个参数时，参数的小括号可以省略
*/
@Test
public void test05(){
//类型推断
Consumer<String> cons3 = (s) -> {
System.out.println(s);
};
cons3.accept("Hello world");
Consumer<String> cons4 = s -> {
System.out.println(s);
};
cons4.accept("Hello world");
}语法格式五 : Lambda 需要两个或以上的参数，多条执行语句，并且可以有返回值
/*
语法格式五：Lambda 需要两个或以上的参数，多条执行语句，并且可以有返回值
*/
@Test
public void test06(){
Comparator<Integer> com1 = new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
System.out.println(o1);
System.out.println(o2);
return o1.compareTo(o2);
}
};
int compare = com1.compare(12, 23);
System.out.println(compare);
System.out.println("*************************");
Comparator<Integer> com2 = (o1, o2) -> {
System.out.println(o1);
System.out.println(o2);
return o1.compareTo(o2);
};
System.out.println(com2.compare(21, 12));
}语法格式六 : 当 Lambda 体只有一条语句时，return 与大括号若有，都可以省略
/*
语法格式六：当 Lambda 体只有一条语句时，return 与大括号若有，都可以省略
*/
@Test
public void test07(){
Comparator<Integer> com = (o1, o2) -> o1.compareTo(o2);
int compare = com.compare(12, 21);
System.out.println(compare);
}总结 :
-> 左边 : lambda形参列表的参数类型可以省略(类型推断);如果lambda形参列表只有一个参数,其一对()也可以省略
-> 右边 : lambda体应该使用一对大括号{}包裹;如果lambda体只有一条执行语句(可能是return语句),可以省略这一对大括号{}以及return关键字二、函数式(Functional)接口
1. 什么是函数式接口
如果一个接口中只声明了一个抽象方法，则此接口就是函数型接口。
你可以通过 Lambda 表达式来创建该接口的对象。（若 Lambda 表达式抛出一个受检异常(即：非运行时异常)，那么该异常需要在目标接口的抽象方法上进行声明）。
我们可以在一个接口上使用 @FunctionalInterface 注解，这样做可以检查它是否是一个函数式接口。同时 javadoc 也会包含一条声明，说明这个接口是一个函数式接口。
在java.util.function包下定义了Java 8 的丰富的函数式接口
@FunctionalInterface
public interface MyInterface {
void method1();
}2. 如何理解函数式接口
Java从诞生日起就是一直倡导“一切皆对象”，在Java里面面向对象(OOP)编程是一切。但是随着python、scala等语言的兴起和新技术的挑战，Java不得不做出调整以便支持更加广泛的技术要求，也即java不但可以支持OOP还可以支持OOF（面向函数编程）
在函数式编程语言当中，函数被当做一等公民对待。在将函数作为一等公民的编程语言中，Lambda表达式的类型是函数。但是在Java8中，有所不同。在Java8中，Lambda表达式是对象，而不是函数，它们必须依附于一类特别的对象类型——函数式接口。
简单的说，在Java8中，Lambda表达式就是一个函数式接口的实例。这就是Lambda表达式和函数式接口的关系。也就是说，只要一个对象是函数式接口的实例，那么该对象就可以用Lambda表达式来表示。
所以以前用匿名实现类表示的现在都可以用Lambda表达式来写。
3. 函数式接口举例
Java内置四大核心函数式接口 :
消费型接口 : Consumer<T> void accept(T t)
供给型接口 : Supplier<T> T get()
函数型接口 : Function<T,R> R apply(T t)
断定型接口 : Predicate<T> boolean test(T t)举例 : 消费型接口
@Test
public void test01(){
happyTime(100, new Consumer<Double>() {
@Override
public void accept(Double aDouble) {
System.out.println("今天很开心，消费" + aDouble);
}
});
System.out.println("********************************");
happyTime(100, aDouble -> System.out.println("今天很开心，消费" + aDouble));
}
/*
result :
今天很开心，消费100.0
********************************
今天很开心，消费100.0
*/
public void happyTime(double money, Consumer<Double> con){
con.accept(money);
}举例 : 断言式接口
@Test
public void test02(){
List<String> list = Arrays.asList("北京", "南京", "天津", "东京", "西京", "普京");
// List<String> resList = filterString(list, new Predicate<String>() {
// @Override
// public boolean test(String s) {
// return s.contains("京");
// }
// });
// System.out.println(resList);
//使用lambda表达式
List<String> resList = filterString(list, s -> s.contains("京"));
System.out.println(resList);
}
public List<String> filterString(List<String> list, Predicate<String> pre){
List<String> resList = new ArrayList<>();
for (String str : list){
if (pre.test(str)){
resList.add(str);
}
}
return resList;
}三、方法引用与构造器引用
1. 方法引用
当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用
方法引用可以看做是Lambda表达式深层次的表达。换句话说，方法引用就是Lambda表达式，也就是函数式接口的一个实例，通过方法的名字来指向一个方法，可以认为是Lambda表达式的一个语法糖。
要求 : 实现接口的抽象方法的参数列表和返回值类型，必须与方法引用的方法的参数列表和返回值类型保持一致
格式：使用操作符 “::” 将类(或对象) 与 方法名分隔开来。
如下三种主要使用情况：
对象::实例方法名
类::静态方法名
类::实例方法名
情况一使用举例 :
// 情况一：对象 :: 实例方法
//Consumer中的void accept(T t)
//PrintStream中的void println(T t)
@Test
public void test1() {
Consumer<String> con = str -> System.out.println(str);
con.accept("测试");
System.out.println("***********************");
PrintStream ps = System.out;
Consumer<String> con2 = ps::println;
con2.accept("测试");
}
//Supplier中的T get()
//Employee中的String getName()
@Test
public void test2() {
Employee emp = new Employee(1001, "Tom", 23, 5600);
Supplier<String> sup = () -> emp.getName();
System.out.println(sup.get());
System.out.println("************************");
Supplier<String> sup2 = emp::getName;
System.out.println(sup2.get());
}情况二使用举例 :
// 情况二：类 :: 静态方法
//Comparator中的int compare(T t1,T t2)
//Integer中的int compare(T t1,T t2)
@Test
public void test3() {
Comparator<Integer> com1 = (o1, o2) -> Integer.compare(o1, o2);
System.out.println(com1.compare(12, 21));
System.out.println("********************");
Comparator<Integer> com2 = Integer::compare;
System.out.println(com2.compare(21, 12));
}
//Function中的R apply(T t)
//Math中的Long round(Double d)
@Test
public void test4() {
Function<Double, Long> fun = num -> Math.round(num);
Long res = fun.apply(12.2);
System.out.println(res);
System.out.println("********************");
Function<Double, Long> func = Math::round;
Long result = fun.apply(12.2);
System.out.println(result);
}情况三使用举例 :
// 情况三：类 :: 实例方法
// Comparator中的int comapre(T t1,T t2)
// String中的int t1.compareTo(t2)
@Test
public void test5() {
Comparator<String> com1 = (s1, s2) -> s1.compareTo(s2);
System.out.println(com1.compare("abc", "abd"));
System.out.println("************************");
Comparator<String> com2 = String :: compareTo;
System.out.println(com2.compare("abc", "abd"));
}
//BiPredicate中的boolean test(T t1, T t2);
//String中的boolean t1.equals(t2)
@Test
public void test6() {
BiPredicate<String, String> pre1 = (s1, s2) -> s1.equals(s2);
System.out.println(pre1.test("abc", "abc"));
System.out.println("************************");
BiPredicate<String, String> pre2 = String :: equals;
System.out.println(pre2.test("abc", "abd"));
}
// Function中的R apply(T t)
// Employee中的String getName();
@Test
public void test7() {
Function<Employee, String> func1 = (emp) -> emp.getName();
System.out.println(func1.apply(new Employee(1001, "Tom", 12, 500)));
System.out.println("***********************");
Function<Employee, String> func2 = Employee::getName;//Employee的对象调用getName方法
System.out.println(func2.apply(new Employee(1001, "Tom", 12, 500)));
}2. 构造器引用
//构造器引用
//Supplier中的T get()
@Test
public void test1(){
Supplier<Employee> sup1 = new Supplier<Employee>() {
@Override
public Employee get() {
return new Employee();
}
};
System.out.println(sup1.get());
System.out.println("*******************");
Supplier<Employee> sup2 = () -> new Employee();
System.out.println(sup2.get());
System.out.println("*****************");
Supplier<Employee> sup3 = Employee :: new;
System.out.println(sup3.get());
}
//Function中的R apply(T t)
@Test
public void test2(){
Function<Integer, Employee> func1 = id -> new Employee(id);
System.out.println(func1.apply(1001));
System.out.println("*******************");
Function<Integer, Employee> func2 = Employee :: new;
System.out.println(func2.apply(1002));
}
//BiFunction中的R apply(T t,U u)
@Test
public void test3(){
BiFunction<Integer, String, Employee> func1 = (id, name) -> new Employee(id, name);
System.out.println(func1.apply(1001, "Tom"));
System.out.println("**************************");
BiFunction<Integer, String, Employee> func2 = Employee :: new;
System.out.println(func2.apply(1002, "Jerry"));
}3. 数组引用
可以把数组看做是一个类，则数组引用的写法与构造器引用一致
//数组引用
//Function中的R apply(T t)
@Test
public void test4(){
Function<Integer, String[]> func1 = length -> new String[length];
System.out.println(Arrays.toString(func1.apply(5)));
System.out.println("********************");
Function<Integer, String[]> func2 = String[] :: new;
System.out.println(Arrays.toString(func2.apply(10)));
}四、强大的StreamAPI
Stream API ( java.util.stream) 把真正的函数式编程风格引入到Java中。这是目前为止对Java类库最好的补充，因为Stream API可以极大提供Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。
Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。 使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简言之，Stream API 提供了一种高效且易于使用的处理数据的方式。
1. 为什么使用StreamAPI
实际开发中，项目中多数数据源都来自于Mysql，Oracle等。但现在数据源可以更多了，有MongDB，Radis等，而这些NoSQL的数据就需要Java层面去处理。
Stream 和 Collection 集合的区别：Collection 是一种静态的内存数据结构，而 Stream 是有关计算的。前者是主要面向内存，存储在内存中，后者主要是面向 CPU，通过 CPU 实现计算。
2. 什么是Stream
Stream是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。
集合讲的是数据，Stream讲的是计算！
注意 :
Stream 自己不会存储元素。
Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。
3. Stream的操作步骤
Stream的执行流程 :
Stream的实例化 : 一个数据源（如：集合、数组），获取一个流
一系列的中间操作(过滤、映射...) : 一个中间操作链，对数据源的数据进行处理
终止操作 : 一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用
4. Stream的实例化
4.1 创建Stream : 通过集合
Java8 中的 Collection 接口被扩展，提供了两个获取流的方法：
default Stream<E> stream() : 返回一个顺序流
default Stream<E> parallelStream() : 返回一个并行流
@Test
public void test01(){
List<Employee> employees = EmployeeData.getEmployees();
//获取一个顺序流
Stream<Employee> stream = employees.stream();
//获取一个并行流
Stream<Employee> parallelStream = employees.parallelStream();
}4.2 创建Stream : 通过数组
Java8 中的 Arrays 的静态方法 stream() 可以获取数组流：
static <T> Stream<T> stream(T[] array) : 返回一个流
重载形式，能够处理对应基本类型的数组：
public static IntStream stream(int[] array)
public static LongStream stream(long[] array)
public static DoubleStream stream(double[] array)
@Test
public void test02(){
int[] arr = new int[5];
IntStream stream = Arrays.stream(arr);
Employee e1 = new Employee(1001, "Tom");
Employee e2 = new Employee(1002, "Jerry");
Employee[] arr1 = new Employee[]{e1, e2};
Stream<Employee> stream1 = Arrays.stream(arr1);
}4.3 创建Stream : 通过Stream的of方法
可以调用Stream类静态方法 of(), 通过显示值创建一个流。它可以接收任意数量的参数。
public static<T> Stream<T> of(T... values) : 返回一个流
@Test
public void test03(){
Stream<Integer> stream = Stream.of(1, 2, 3, 4);
}4.4 创建Stream : 创建无限流
可以使用静态方法 Stream.iterate() 和 Stream.generate(), 创建无限流。造数据
迭代 public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
生成 public static<T> Stream<T> generate(Supplier<T> s)
/*
创建Stream的方式四 : 通过无限流 -> 造数据
*/
@Test
public void test04(){
// 迭代
// public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
//遍历 : 从0开始的偶数 限制前十个数据
Stream.iterate(0, t -> t+2).limit(10).forEach(System.out::println);
// 生成
// public static<T> Stream<T> generate(Supplier<T> s)
Stream.generate(Math::random).limit(10).forEach(System.out::println);
}5. Stream的中间操作
多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值”。
5.1 筛选与切片
filter(Predicate p) : 接收 Lambda ， 从流中排除某些元素
distinct() : 筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
limit(long maxSize) : 截断流，使其元素不超过给定数量
skip(long n) : 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补
//1. 筛选与切片 @Test public void test01(){ List<Employee> list = EmployeeData.getEmployees(); Stream<Employee> stream = list.stream(); //filter(Predicate p) : 接收 Lambda，从流中排除某些元素 //练习 : 找出工资大于7000的员工 stream.filter(employee -> employee.getSalary() > 7000).forEach(System.out::println); System.out.println(); //limit(long maxSize) : 截断流，使其元素不超过给定数量 //注意 stream 一旦执行了终止操作就关闭了 如果再次使用会报异常 //java.lang.IllegalStateException: stream has already been operated upon or closed //练习 : 输出前三个员工信息 list.stream().limit(3).forEach(System.out::println); System.out.println(); //skip(long n) : 跳过元素，返回一个扔掉了前 n 个元素的流。 // 若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补 //练习 : 跳过前三个员工 list.stream().skip(3).forEach(System.out::println); System.out.println(); //distinct() : 筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素 list.add(new Employee(1009, "侯德阳", 20, 15500)); list.add(new Employee(1009, "侯德阳", 20, 15500)); list.add(new Employee(1009, "侯德阳", 20, 15500)); list.add(new Employee(1009, "侯德阳", 20, 15500)); list.stream().distinct().forEach(System.out::println); } /* result : Employee{id=1002, name='马云', age=12, salary=9876.12} Employee{id=1004, name='雷军', age=26, salary=7657.37} Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43} Employee{id=1001, name='马化腾', age=34, salary=6000.38} Employee{id=1002, name='马云', age=12, salary=9876.12} Employee{id=1003, name='刘强东', age=33, salary=3000.82} Employee{id=1004, name='雷军', age=26, salary=7657.37} Employee{id=1005, name='李彦宏', age=65, salary=5555.32} Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43} Employee{id=1007, name='任正非', age=26, salary=4333.32} Employee{id=1008, name='扎克伯格', age=35, salary=2500.32} Employee{id=1001, name='马化腾', age=34, salary=6000.38} Employee{id=1002, name='马云', age=12, salary=9876.12} Employee{id=1003, name='刘强东', age=33, salary=3000.82} Employee{id=1004, name='雷军', age=26, salary=7657.37} Employee{id=1005, name='李彦宏', age=65, salary=5555.32} Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43} Employee{id=1007, name='任正非', age=26, salary=4333.32} Employee{id=1008, name='扎克伯格', age=35, salary=2500.32} Employee{id=1009, name='侯德阳', age=20, salary=15500.0} Process finished with exit code 0 */
5.2 映射
map(Function f) : 接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
mapToDouble(ToDoubleFunction f) : 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 DoubleStream。
mapToInt(ToIntFunction f) : 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 IntStream。
mapToLong(ToLongFunction f) : 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 LongStream。
flatMap(Function f) : 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
//2. 映射 @Test public void test02(){ //map(Function f) : 接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。 List<String> list = Arrays.asList("aa", "bb", "cc"); list.stream().map(String::toUpperCase).forEach(System.out::println); System.out.println(); //练习 : 获取员工姓名长度大于3的员工的姓名 List<Employee> employees = EmployeeData.getEmployees(); employees.stream().map(Employee::getName).filter(str -> str.length() > 3).forEach(System.out::println); System.out.println(); //通过map映射将每个字符串都转换为stream 形成streamStream 通过两次forEach遍历出来 Stream<Stream<Character>> streamStream = list.stream().map(StreamAPITest1::fromStringToStream); streamStream.forEach(stream -> stream.forEach(System.out::println)); System.out.println(); //flatMap(Function f) : 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流 //如果使用 flatMap 就会自动将内层的stream拆开 list.stream().flatMap(StreamAPITest1::fromStringToStream).forEach(System.out::println); //对于集合中套集合的方式 要遍历每一个元素 则使用flatMap } /** * @Description 将字符串转换为字符数组的Stream * @author hjc * @param str 输入的字符串 * @returnType java.util.stream.Stream<java.lang.Character> */ public static Stream<Character> fromStringToStream(String str){ List<Character> list = new ArrayList<>(); for (char character : str.toCharArray()){ list.add(character); } return list.stream(); } /* result : AA BB CC 比尔盖茨 扎克伯格 a a b b c c a a b b c c Process finished with exit code 0 */
5.3 排序
sorted() : 产生一个新流，其中按自然顺序排序
sorted(Comparator com) : 产生一个新流，其中按比较器顺序排序
//3. 排序 @Test public void test04(){ List<Integer> list = Arrays.asList(1, 6, 4, 3); //按照自然排序 list.stream().sorted().forEach(System.out::println); List<Employee> employees = EmployeeData.getEmployees(); //按照年龄从小到大 按照工资从小到大 employees.stream().sorted((e1, e2) -> { int ageValue = Integer.compare(e1.getAge(), e2.getAge()); if (ageValue != 0){ return ageValue; } else { return Double.compare(e1.getSalary(), e2.getSalary()); } }).forEach(System.out::println); } /* result : Employee{id=1002, name='马云', age=12, salary=9876.12} Employee{id=1007, name='任正非', age=26, salary=4333.32} Employee{id=1004, name='雷军', age=26, salary=7657.37} Employee{id=1003, name='刘强东', age=33, salary=3000.82} Employee{id=1001, name='马化腾', age=34, salary=6000.38} Employee{id=1008, name='扎克伯格', age=35, salary=2500.32} Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43} Employee{id=1005, name='李彦宏', age=65, salary=5555.32} Process finished with exit code 0 */
6. Stream的终止操作
6.1 匹配与查找
allMatch(Predicate p) : 检查是否匹配所有元素
anyMatch(Predicate p) : 检查是否至少匹配一个元素
noneMatch(Predicate p) : 检查是否没有匹配所有元素
findFirst() : 返回第一个元素
findAny() : 返回当前流中的任意元素
count() : 返回流中元素总数
max(Comparator c) : 返回流中最大值
min(Comparator c) : 返回流中最小值
forEach(Consumer c) : 内部迭代(使用 Collection 接口需要用户去做迭代，称为外部迭代。相反，Stream API 使用内部迭代——它帮你把迭代做了)
@Test public void test01(){ List<Employee> employees = EmployeeData.getEmployees(); //allMatch(Predicate p) : 检查是否匹配所有元素 //练习 : 是否所有的员工年龄大于18岁 boolean allMatch = employees.stream().allMatch(emp -> emp.getAge() > 18); System.out.println(allMatch);//false //anyMatch(Predicate p) : 检查是否至少匹配一个元素 //练习 : 是否存在员工的工资大于10000 boolean anyMatch = employees.stream().anyMatch(emp -> emp.getSalary() > 10000); System.out.println(anyMatch);//false //noneMatch(Predicate p) : 检查是否没有匹配所有元素 //练习 : 是否存在员工姓'雷' boolean noneMatch = employees.stream().noneMatch(emp -> emp.getName().startsWith("雷")); System.out.println(noneMatch);//false //findFirst() : 返回第一个元素 //找出工资最高的员工 Optional<Employee> employee = employees.stream() .sorted((e1, e2) -> -Double.compare(e1.getSalary(), e2.getSalary())).findFirst(); System.out.println(employee); //Optional[Employee{id=1008, name='扎克伯格', age=35, salary=2500.32}] //findAny() : 返回当前流中的任意元素 Optional<Employee> anyEmployee = employees.stream().findAny(); System.out.println(anyEmployee); //Optional[Employee{id=1001, name='马化腾', age=34, salary=6000.38}] //count() : 返回流中元素总数 long count = employees.stream().filter(emp -> emp.getSalary() > 5000).count(); System.out.println(count);//5 //max(Comparator c) : 返回流中最大值 //找出最高的工资 Optional<Double> maxSalary = employees.stream().map(Employee::getSalary).max(Double::compare); System.out.println(maxSalary);//Optional[9876.12] //min(Comparator c) : 返回流中最小值 //找出年龄最小员工 Optional<Employee> min = employees.stream().min((e1, e2) -> Integer.compare(e1.getAge(), e2.getAge())); System.out.println(min); //Optional[Employee{id=1002, name='马云', age=12, salary=9876.12}] //forEach(Consumer c) : 内部迭代 employees.stream().forEach(System.out::println); //使用集合的遍历操作 employees.forEach(System.out::println); } /* result : false false false Optional[Employee{id=1002, name='马云', age=12, salary=9876.12}] Optional[Employee{id=1001, name='马化腾', age=34, salary=6000.38}] 5 Optional[9876.12] Optional[Employee{id=1002, name='马云', age=12, salary=9876.12}] */
6.2 归约
reduce(T iden, BinaryOperator b) : 可以将流中元素反复结合起来，得到一个值。返回 T
reduce(BinaryOperator b) : 可以将流中元素反复结合起来，得到一个值。返回 Optional<T>
说明 : map 和 reduce 的连接通常称为 map-reduce 模式，因 Google 用它来进行网络搜索而出名。
//2. 归约
@Test
public void test02(){
//reduce(T iden, BinaryOperator b) : 可以将流中元素反复结合起来，得到一个值。返回 T
//计算 1-10 的自然数的和
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
//reduce的第一个参数是初始值
Integer sum = list.stream().reduce(0, Integer::sum);
System.out.println(sum);//55
//reduce(BinaryOperator b) : 可以将流中元素反复结合起来，得到一个值。返回 Optional<T>
List<Employee> employees = EmployeeData.getEmployees();
Optional<Double> sumSalary = employees.stream().map(Employee::getSalary).reduce(Double::sum);
// employees.stream().map(Employee::getSalary).reduce((d1, d2) -> d1 + d2);
System.out.println(sumSalary);//Optional[48424.08]
}6.3 收集
collect(Collector c) : 将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法
Collector 接口中方法的实现决定了如何对流执行收集的操作(如收集到 List、Set、Map)。
另外， Collectors 实用类提供了很多静态方法，可以方便地创建常见收集器实例。
//3. 收集
@Test
public void test04(){
//collect(Collector c) : 将流转换为其他形式。
// 接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法
//练习 : 查找工资大于6000的员工 结果返回一个List或Set
List<Employee> employees = EmployeeData.getEmployees();
List<Employee> collect = employees.stream().filter(emp -> emp.getSalary() > 6000).collect(Collectors.toList());
collect.forEach(System.out::println);
System.out.println();
Set<Employee> collectSet = employees.stream().filter(emp -> emp.getSalary() > 6000).collect(Collectors.toSet());
collectSet.forEach(System.out::println);
}
/*
result :
Employee{id=1001, name='马化腾', age=34, salary=6000.38}
Employee{id=1002, name='马云', age=12, salary=9876.12}
Employee{id=1004, name='雷军', age=26, salary=7657.37}
Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}
Employee{id=1001, name='马化腾', age=34, salary=6000.38}
Employee{id=1002, name='马云', age=12, salary=9876.12}
Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}
Employee{id=1004, name='雷军', age=26, salary=7657.37}
Process finished with exit code 0
*/五、Optional类
到目前为止，臭名昭著的空指针异常是导致Java应用程序失败的最常见原因。以前，为了解决空指针异常，Google公司著名的Guava项目引入了Optional类，Guava通过使用检查空值的方式来防止代码污染，它鼓励程序员写更干净的代码。受到Google Guava的启发，Optional类已经成为Java 8类库的一部分。
Optional<T> 类(java.util.Optional) 是一个容器类，它可以保存类型T的值，代表这个值存在。或者仅仅保存null，表示这个值不存在。原来用 null 表示一个值不存在，现在 Optional 可以更好的表达这个概念。并且可以避免空指针异常。
Optional类的Javadoc描述如下：这是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。
1. 创建Optional类对象
Optional.of(T t) : 创建一个 Optional 实例，t必须非空；
Optional.empty() : 创建一个空的 Optional 实例
Optional.ofNullable(T t) : t 可以为null
/* 创建Optional类对象 */ @Test public void test01(){ Girl girl = new Girl(); // girl = null; //of() : 创建一个Optional实例,t必须是非空的 Optional<Girl> optionalGirl = Optional.of(girl); System.out.println(optionalGirl);//Optional[Girl{name='null'}] //empty() : 创建一个空的Optional实例 Optional<Object> objectOptional = Optional.empty(); System.out.println(objectOptional);//Optional.empty //ofNullable() : t 可以为null girl = null; Optional<Girl> optionalGirl1 = Optional.ofNullable(girl); System.out.println(optionalGirl1);//Optional.empty }
2. Optional类的常用方法
判断Optional容器中是否包含对象：
boolean isPresent() : 判断是否包含对象
void ifPresent(Consumer<? super T> consumer) : 如果有值，就执行Consumer接口的实现代码，并且该值会作为参数传给它。
获取Optional容器的对象：
T get() : 如果调用对象包含值，返回该值，否则抛异常
T orElse(T other) : 如果有值则将其返回，否则返回指定的other对象。
T orElseGet(Supplier<? extends T> other) : 如果有值则将其返回，否则返回由Supplier接口实现提供的对象。
T orElseThrow(Supplier<? extends X> exceptionSupplier) : 如果有值则将其返回，否则抛出由Supplier接口实现提供的异常。
/* of()方法与get()方法搭配使用 */ @Test public void test06(){ Boy boy = new Boy(); Optional<Boy> optionalBoy = Optional.of(boy); System.out.println(optionalBoy.isPresent());//true optionalBoy.ifPresent(System.out::println);//Boy{girl=null} //通常与of方法搭配使用 用于获取封装的数据 Boy boy1 = optionalBoy.get(); System.out.println(boy1);//Boy{girl=null} } /* ofNullable()与orElse()搭配使用 */ @Test public void test02(){ String str = "北京"; str = null; Optional<String> optionalS = Optional.ofNullable(str); String s = optionalS.orElse("上海"); System.out.println(s); }
3. Optional类使用举例
为了在程序中避免出现空指针异常
/*
Optional类使用举例
*/
public String getGirlName(Boy boy){
return boy.getGirl().getName();
}
/*
使用Optional类之前
*/
@Test
public void test02(){
Boy boy = new Boy();
String girlName = getGirlName(boy);
System.out.println(girlName);
}
//优化以后的getGirlName方法 :
public String getGirlName1(Boy boy){
if (boy != null){
Girl girl = boy.getGirl();
if (girl != null){
return girl.getName();
}
}
return null;
}
@Test
public void test04(){
Boy boy = new Boy();
String girlName1 = getGirlName1(boy);
System.out.println(girlName1);//null
}
//使用Optional类后的getGirlName方法 :
public String getGirlName2(Boy boy){
//将boy包装进Optional中
Optional<Boy> optionalBoy = Optional.ofNullable(boy);
//此时返回的boy一定是非空的
Boy boy1 = optionalBoy.orElse(new Boy());
Girl girl = boy1.getGirl();
Optional<Girl> optionalGirl = Optional.ofNullable(girl);
//此时返回的girl1一定是非空的
Girl girl1 = optionalGirl.orElse(new Girl("迪丽热巴"));
return girl1.getName();
}
@Test
public void test05(){
Boy nullBoy = null;
String girlName2 = getGirlName2(nullBoy);
System.out.println(girlName2);//迪丽热巴
Boy boy = new Boy(new Girl("古力娜扎"));
String girlName21 = getGirlName2(boy);
System.out.println(girlName21);//古力娜扎
}