第十六章：Java8的其他新特性
2021年3月12日
17:14
Lambda表达式的使用
1.举例： (o1,o2) -> Integer.compare(o1,o2);
2.格式：
-> : lambda操作符 或 箭头操作符
->左边：lambda形参列表 （其实就是接口中的抽象方法的形参列表）
->右边：lambda体 （其实就是重写的抽象方法的方法体）
3. Lambda表达式的使用：（分为6种情况介绍）
总结：
->左边：lambda形参列表的参数类型可以省略(类型推断)；如果lambda形参列表只有一个参数，其一对()也可以省略
->右边：lambda体应该使用一对{}包裹；如果lambda体只有一条执行语句（可能是return语句），省略这一对{}和return关键字
|
语法格式一：无参，无返回值 Runnable r2 = () -> { System.out.println("我爱北京故宫"); }; 语法格式二：Lambda 需要一个参数，但是没有返回值。 Consumer<String> con1 = (String s) -> { System.out.println(s); }; 语法格式三：数据类型可以省略，因为可由编译器推断得出，称为“类型推断” Consumer<String> con2 = (s) -> { System.out.println(s); }; 语法格式四：Lambda 若只需要一个参数时，参数的小括号可以省略 Consumer<String> con2 = s -> { System.out.println(s); }; 语法格式五：Lambda 需要两个或以上的参数，多条执行语句，并且可以有返回值 Comparator<Integer> com2 = (o1,o2) -> { System.out.println(o1); System.out.println(o2); return o1.compareTo(o2); }; 语法格式六：当 Lambda 体只有一条语句时，return 与大括号若有，都可以省略 Comparator<Integer> com2 = (o1, o2) -> o1.compareTo(o2); |
4.Lambda表达式的本质：作为函数式接口的实例
在Java8中，Lambda表达式是对象，而不是函数，它们必须依附于一类特别的对象类型——函数式接口。
5. 如果一个接口中，只声明了一个抽象方法，则此接口就称为函数式接口。我们可以在一个接口上使用 @FunctionalInterface 注解，这样做可以检查它是否是一个函数式接口。
6. 所以以前用匿名实现类表示的现在都可以用Lambda表达式来写。
作为参数传递 Lambda 表达式：为了将 Lambda 表达式作为参数传递，接收Lambda表达式的参数类型必须是与该 Lambda 表达式兼容的函数式接口的类型。
|
@FunctionalInterface interface MyInter { String toUpperCase(String s); }
public class LambdaPara { @Test public void test1(){ //作为参数传递 Lambda 表达式： String upper = show(s -> s.toUpperCase(), "abc"); System.out.println(upper); //ABC }
public static String show(MyInter m,String str){ return m.toUpperCase(str); } } |
Java 内置四大核心函数式接口
消费型接口 Consumer<T> void accept(T t)
供给型接口 Supplier<T> T get()
函数型接口 Function<T,R> R apply(T t)
断定型接口 Predicate<T> boolean test(T t)
其他接口
方法引用(Method References)
1.使用情境：当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！
2.方法引用可以看做是Lambda表达式深层次的表达，本质上就是Lambda表达式，而Lambda表达式作为函数式接口的实例。所以方法引用，也是函数式接口的实例。
3. 使用格式： 类(或对象) :: 方法名
4. 具体分为如下的三种情况：
* 情况1 对象 :: 非静态方法（实例方法）
* 情况2 类 :: 静态方法
*
* 情况3 类 :: 非静态方法（实例方法）
5. 方法引用使用的要求：要求接口中的抽象方法的形参列表和返回值类型与方法引用的方法的形参列表和返回值类型相同！（针对于情况1和情况2）
注意：当函数式接口方法的第一个参数是需要引用方法的调用者，并且第二个参数是需要引用方法的参数(或无参数)时才可以用：ClassName::methodName 类名::实例方法
|
// 情况三：类 :: 实例方法 // 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("aaa","aba"));
System.out.println(); //第一个参数是需要引用方法的调用者，并且第二个参数是需要引用方法的参数 Comparator<String> com2 = String :: compareTo; System.out.println(com2.compare("qwr", "safsa")); } |
构造器引用
格式： ClassName::new
* 和方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致。
* 抽象方法的返回值类型即为构造器所属的类的类型
|
//BiFunction中的R apply(T t,U u) @Test public void test3(){ BiFunction<Integer,String,Employee> biFunc = (age,name) -> new Employee(age,name); System.out.println(biFunc.apply(15,"御坂美琴")); //Employee{id=15, name='御坂美琴', age=0, salary=0.0}
BiFunction<Integer,String,Employee> biFunc1 = Employee::new; //Employee{id=18, name='圣人惠', age=0, salary=0.0} System.out.println(biFunc1.apply(18,"圣人惠")); } 对应会找到这个构造器： public Employee(int id, String name) { this.id = id; this.name = name; } |
数组引用
格式： type[] :: new
* 可以把数组看做是一个特殊的类，则写法与构造器引用一致。
|
//数组引用 //Function中的Rapply(Tt) Function<Integer,String[]> func = length -> new String[length]; System.out.println(Arrays.toString(func.apply(10)));
Function<Integer,String[]> func1 = String[]::new; System.out.println(Arrays.toString(func1.apply(5))); |
Stream API
1. Stream关注的是对数据的运算，与CPU打交道
* 集合关注的是数据的存储，与内存打交道
l Stream 和 Collection 集合的区别：Collection 是一种静态的内存数据结构，而 Stream 是有关计算的。前者是主要面向内存，存储在内存中，后者主要是面向 CPU，通过 CPU 实现计算。
2.注意
* ①Stream 自己不会存储元素。
* ②Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
* ③Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行
3.Stream 执行流程
* ① Stream的实例化
* ② 一系列的中间操作（过滤、映射、...)
* ③ 终止操作
4.说明：
* 4.1 一个中间操作链，对数据源的数据进行处理
* 4.2 一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用
Stream的实例化
创建 Stream方式一：通过集合
Java8 中的 Collection 接口被扩展，提供了两个获取流的方法：
l default Stream<E> stream() : 返回一个顺序流
|
Stream<Employee> stream = employees.stream(); |
l default Stream<E> parallelStream() : 返回一个并行流
|
Stream<Employee> parallelStream = employees.parallelStream(); |
创建 Stream方式二：通过数组
Java8 中的 Arrays 的静态方法 stream() 可以获取数组流：
l static <T> Stream<T> stream(T[] array): 返回一个流
|
Employee[] employees = new Employee[5]; Stream<Employee> employeeStream = Arrays.stream(employees); |
重载形式，能够处理对应基本类型的数组：
l public static IntStream stream(int[] array)
l public static LongStream stream(long[] array)
l public static DoubleStream stream(double[] array)
|
int[] arr = new int[]{1,2,3,4,5,6}; IntStream stream = Arrays.stream(arr); |
创建 Stream方式三：通过Stream的of()
可以调用Stream类静态方法 of(), 通过显示值创建一个流。它可以接收任意数量的参数。
l public static<T> Stream<T> of(T... values) : 返回一个流
|
Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 6); |
创建 Stream方式四：创建无限流 （不常用）
可以使用静态方法 Stream.iterate() 和 Stream.generate(),创建无限流。
l 迭代
public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
l 生成
public static<T> Stream<T> generate(Supplier<T> s)
|
//迭代 //遍历前10个偶数 Stream.iterate(0,t -> t + 2).limit(10).forEach(System.out::println);
//生成Stream.generate(Math::random).limit(10).forEach(System.out::println); |
Stream 的中间操作
多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值”。
1-筛选与切片
|
filter(Predicate p)——接收 Lambda ， 从流中排除某些元素。 limit(n)——截断流，使其元素不超过给定数量。 skip(n) —— 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补 distinct()——筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素 |
2-映 射
|
map(Function f)——接收一个函数作为参数，将元素转换成其他形式或提取信息，该函数会被应用到每个元素上，并将其映射成一个新的元素。 flatMap(Function f)——接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。 |
|
//练习1：获取员工姓名长度大于3的员工的姓名。 Stream<Employee> stream1 = EmployeeData.getEmployees().stream(); stream1.map(Employee::getName).filter(s -> s.length() > 3).forEach(System.out::println);
//练习2：把list变成字符拆开输出 List<String> list = Arrays.asList("aa","bb","cc","dd"); //①用map实现 //Stream()中的每一个元素（字符串）代入fromStringToStream()进行运算，返回一个Stream<Character> //四个元素就变成了一个由Stream<Character>组成的Stream<Stream<Character>> Stream<Stream<Character>> s = list.stream().map(StreamAPITest1::fromStringToStream); //遍历Stream<Stream<Character>>，每一个元素就是一个Stream<Character> //每一个Stream<Character>再执行forEach运算，把其中的每个Character输出 s.forEach(stream -> stream.forEach( System.out::println ));
//② flatMap用方法引用简写 //public abstract <R> Stream<R> flatMap(java.util.function.Function<? super T, ? extends Stream<? extends R>> mapper) //解析：flatMap是一个抽象方法，里面的参数是一个Function操作 //其中apply方法的参数是(? super T)，T是Stream<T>，也就是String。返回值是(? extends Stream<? extends R>)，可以是继承于R的任意类型的一个Stream //fromStringToStream的写法就是传入一个字符串，返回一个Stream<Character> list.stream().flatMap(StreamAPITest1::fromStringToStream).forEach(System.out::println);
//③flatMap只用lambda表达式 list.stream().flatMap(a -> { ArrayList<Character> list1 = new ArrayList<>(); //.toCharArray() for(Character c : a.toCharArray()){ list1.add(c); } return list1.stream(); }).forEach(System.out::println);
//④flatMap原始写法 list.stream().flatMap(new Function<String,Stream<Character>>(){
@Override public Stream<Character> apply(String s) { ArrayList<Character> list = new ArrayList<>(); //.toCharArray() for(Character c : s.toCharArray()){ list.add(c); } return list.stream(); } }).forEach(System.out::println);
//将字符串中的多个字符构成的集合转换为对应的Stream的实例 public static Stream<Character> fromStringToStream(String s){ ArrayList<Character> list = new ArrayList<>(); //String的toCharArray() for(Character c : s.toCharArray()){ list.add(c); } return list.stream(); } |
用新变量存了返回的流，终止新的流了，原来的流会终止吗？
会终止！哪怕是像上面的例子一样，更改了Stream的泛型
String的 toCharArray() ，转成字符数组
|
对比add()和addAll()理解map()和flatMap() ArrayList list = new ArrayList(); list.add(1); list.add(2); list.add(3); ArrayList list1 = new ArrayList(); list1.add(4); list1.add(5); list1.add(6); list.add(list1); //把集合当成一个对象加进集合 [1, 2, 3, [4, 5, 6]] list.addAll(list1); //把集合里的元素全部加进集合 [1, 2, 3, 4, 5, 6] |
3-排序
|
sorted() 产生一个新流，其中按自然顺序排序。需要implements Comparable接口 sorted(Comparator com) 产生一个新流，其中按比较器顺序排序 |
Stream 的终止操作
l 终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List、Integer，甚至是 void 。
l 流进行了终止操作后，不能再次使用。
1-匹配与查找
|
allMatch(Predicate p)——检查是否匹配所有元素。 anyMatch(Predicate p)——检查是否至少匹配一个元素。 noneMatch(Predicate p)——检查是否没有匹配的元素。 findFirst——返回第一个元素 findAny——返回当前流中的任意元素 count——返回流中元素的总个数 max(Comparator c)——返回流中最大值 min(Comparator c)——返回流中最小值 forEach(Consumer c)——内部迭代 employees.stream().forEach(System.out::println); //区分使用集合的遍历操作 employees.forEach(System.out::println); |
2-归约
|
reduce(T identity, BinaryOperator)——可以将流中元素反复结合起来，得到一个值。返回 T。T identity是初始值。 reduce(BinaryOperator) ——可以将流中元素反复结合起来，得到一个值。返回 Optional<T> //包装类的sum()方法，刚好也是两个参数T，返回一个T，符合BinaryOperator Integer reduce = list.stream().reduce(0, Integer::sum); |
映射和归约：map 和 reduce 的连接通常称为 map-reduce 模式，因 Google用它来进行网络搜索而出名。
3-收集
|
collect(Collector c)——将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法 |
Collector 接口中方法的实现决定了如何对流执行收集的操作(如收集到 List、Set、Map)。
另外， Collectors 实用类提供了很多静态方法，可以方便地创建常见收集器实例
|
List<Employee> collect = employees.stream().collect(Collectors.toList()); Set<Employee> collect1 = employees.stream().collect(Collectors.toSet()); |
Optional类
l Optional类的Javadoc描述如下：这是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。
l Optional提供很多有用的方法，这样我们就不用显式进行空值检测。
l 创建Optional类对象的方法：
Ø Optional.of(T t) : 创建一个 Optional 实例，t必须非空；
Ø Optional.empty() : 创建一个空的 Optional 实例
Ø Optional.ofNullable(T t)：t可以为null
l 判断Optional容器中是否包含对象：
Ø boolean isPresent() : 判断是否包含对象
Ø void ifPresent(Consumer<? super T> consumer) ：如果有值，就执行Consumer接口的实现代码，并且该值会作为参数传给它。
l 获取Optional容器的对象：
Ø T get(): 如果调用对象包含值，返回该值，否则抛异常
Ø T orElse(T other) ：如果有值则将其返回，否则返回指定的other对象。
Ø T orElseGet(Supplier<? extends T> other) ：如果有值则将其返回，否则返回由Supplier接口实现提供的对象。
Ø T orElseThrow(Supplier<? extends X> exceptionSupplier) ：如果有值则将其返回，否则抛出由Supplier接口实现提供的异常。
|
public String getGirlName2(Boy boy){ Optional<Boy> optionalBoy = Optional.ofNullable(boy); //此时的boy1一定非空 Boy boy1 = optionalBoy.orElse(new Boy(new Girl("御坂美琴")));
Optional<Girl> girl = Optional.ofNullable(boy1.getGirl()); //returnGirl一定非空 Girl returnGirl = girl.orElse(new Girl("白井黑子")); return returnGirl.getName(); }
@Test public void test5(){ Boy boy = null; boy = new Boy(); boy = new Boy(new Girl("初春饰利")); String girlName2 = getGirlName2(boy); System.out.println(girlName2); } |
get()通常与of()方法搭配使用。用于获取内部的封装的数据value。要求非空。
orElse()通常和ofNullable()方法搭配使用。可以为空。
2021年3月13日21:19:45 完结。结尾拉到上面。
2021年3月14日23:08:21 增加上面两段话，12号，加粗。
结尾