Lambda表达式的使用

举例

(o1,o2) -> Integer.compare(o1,o2);

格式

->：lambda操作符 或 箭头操作符
->左边：lambda形参列表（其实就是接口中的抽象方法的形参列表）
->右边：lambda体（其实就是重写的抽象方法的方法体）

  1. public class LambdaTest {
  3.     @Test
  4.     public void test1(){
  6.         Runnable r1 = new Runnable() {
  7.             @Override
  8.             public void run() {
  9.                 System.out.println("我爱北京天安门");
  10.             }
  11.         };
  13.         r1.run();
  15.         Runnable r2 = () -> System.out.println("我爱北京故宫");
  17.         r2.run();
  19.     }
  20.     @Test
  21.     public void test2(){
  22.         Comparator<Integer> com1 = new Comparator<Integer>() {
  23.             @Override
  24.             public int compare(Integer o1, Integer o2) {
  25.                 return Integer.compare(o1,o2);
  26.             }
  27.         };
  29.         int compare = com1.compare(12, 21);
  30.         System.out.println(compare);
  31.         //Lambda表达式的写法
  32.         Comparator<Integer> com2 = ((o1, o2) -> Integer.compare(o1,o2));
  34.         int compare2 = com2.compare(32,23);
  35.         System.out.println(compare2);
  37.         //方法引用
  38.         Comparator<Integer> com3 = Integer :: compare;
  40.         int compare3 = com2.compare(32,23);
  41.         System.out.println(compare3);
  42.     }
  44. }

语法格式（6种）

总结

->左边：lambda形参列表的参数类型可以省略（类型推断），如果lambda形参列表只有一个参数，其一对（）也可以省略
->右边：lambda体应该使用一对{}包裹，如果lambda体只有一条执行语句（可能是return语句），可以省略这一对{}和return关键字
屏幕截图 2022-04-20 085458.jpg
屏幕截图 2022-04-20 085536.jpg

  1. //语法格式一：无参，无返回值
  2.     @Test
  3.     public void test3(){
  4.         Runnable r1 = new Runnable() {
  5.             @Override
  6.             public void run() {
  7.                 System.out.println("我爱北京天安门");
  8.             }
  9.         };
  11.         r1.run();
  13.         Runnable r2 = () -> System.out.println("我爱北京故宫");
  15.         r2.run();
  16.     }
  18.     //语法格式二：Lambda 需要一个参数，但是没有返回值
  19.     @Test
  20.     public void test4(){
  21.         Consumer<String> con = new Consumer<String>() {
  22.             @Override
  23.             public void accept(String s) {
  24.                 System.out.println(s);
  25.             }
  26.         };
  27.         con.accept("谎言与誓言的区别");
  29.         System.out.println();
  31.         Consumer<String> con1 = (String s) -> {
  32.             System.out.println(s);
  33.         };
  34.         con1.accept("一个是听的人当真，一个是说的人当真");
  35.     }
  37.     //语法格式三：数据类型可以省略，因为可由编译器推断出，称为”类型推断“
  38.     @Test
  39.     public void test5(){
  40.         Consumer<String> con1 = (String s) -> {
  41.             System.out.println(s);
  42.         };
  43.         con1.accept("一个是听的人当真，一个是说的人当真");
  45.         System.out.println();
  47.         Consumer<String> con2 = (s) -> {
  48.             System.out.println(s);
  49.         };
  50.         con2.accept("一个是听的人当真，一个是说的人当真");
  52.     }
  53.     //语法格式四：Lambda 若只需要一个参数时，参数的小括号可以省略
  54.     @Test
  55.     public void test6(){
  56.         Consumer<String> con1 = (String s) -> {
  57.             System.out.println(s);
  58.         };
  59.         con1.accept("一个是听的人当真，一个是说的人当真");
  61.         System.out.println();
  63.         Consumer<String> con2 = s -> {
  64.             System.out.println(s);
  65.         };
  66.         con2.accept("一个是听的人当真，一个是说的人当真");
  67.     }
  69.     //语法格式五：Lambda 需要两个或两个以上的参数，多条执行语句，并且可以有返回值
  70.     @Test
  71.     public void test7(){
  72.         Comparator<Integer> com1 = new Comparator<Integer>() {
  73.             @Override
  74.             public int compare(Integer o1, Integer o2) {
  75.                 System.out.println(o1);
  76.                 System.out.println(o2);
  77.                 return o1.compareTo(o2);
  78.             }
  79.         };
  80.         System.out.println(com1.compare(12,21));
  82.         System.out.println();
  84.         Comparator<Integer> com2 = (o1,o2) -> {
  85.             System.out.println(o1);
  86.             System.out.println(o2);
  87.             return o1.compareTo(o2);
  88.         };
  89.         System.out.println(com2.compare(2,-1));
  90.     }
  92.     //语法格式六：当Lambda 体只有一条语句时，return 与大括号若有，都可以省略
  93.     @Test
  94.     public void test8(){
  95.         Comparator<Integer> com1 = (o1,o2) -> {
  97.             return o1.compareTo(o2);
  98.         };
  99.         System.out.println(com1.compare(2,-1));
  101.         System.out.println();
  103.         Comparator<Integer> com2 = (o1,o2) -> o1.compareTo(o2);
  105.         System.out.println(com2.compare(12,6));
  107.     }
  109.     @Test
  110.     public void test9(){
  111.         Consumer<String> con1 = s -> {
  112.             System.out.println(s);
  113.         };
  114.         con1.accept("一个是听的人当真，一个是说的人当真");
  116.         System.out.println();
  118.         Consumer<String> con2 = s -> System.out.println(s);
  120.         con2.accept("一个是听的人当真，一个是说的人当真");
  121.     }

函数式接口屏幕截图 2022-04-20 150818.jpg

使用

  1. public class LambdaTest1 {
  3.     @Test
  4.     public void test1(){
  6.         happyTime(500, new Consumer<Double>() {
  7.             @Override
  8.             public void accept(Double aDouble) {
  9.                 System.out.println("买一瓶水" + aDouble);
  10.             }
  11.         });
  12.         System.out.println();
  14.         happyTime(400,money -> System.out.println("买一瓶水" + money));
  15.     }
  17.     public void happyTime(double money, Consumer<Double> con){
  18.         con.accept(money);
  19.     }
  21.     @Test
  22.     public void test2(){
  24.         List<String> list = Arrays.asList("新乡","北京","南京","东京","西京");
  25.         List<String> filterStrs = filterString(list, new Predicate<String>() {
  26.             @Override
  27.             public boolean test(String s) {
  28.                 return s.contains("京");
  29.             }
  30.         });
  32.         System.out.println(filterStrs);
  34.         List<String> filterStrs1 = filterString(list,s -> s.contains("新"));
  35.         System.out.println(filterStrs1);
  36.     }
  38.     //根据给定的规则，过滤集合中的字符串。此规则由Predicate的方法决定
  39.     public List<String> filterString(List<String> list , Predicate<String> pre){
  41.         ArrayList<String> filterList = new ArrayList<>();
  43.         for (String s : list){
  44.             if (pre.test(s)){
  45.                 filterList.add(s);
  46.             }
  47.         }
  49.         return filterList;
  51.     }
  52. }

方法引用的使用

方法引用，本质上就是Lambda表达式，而Lambda表达式作为函数式接口的实例，所以方法引用，也是函数式接口的实例

使用情景

当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用

格式

类（或对象） :：方法名

三种情况

对象 :: 非静态方法

  1.  //情况一：对象 :: 实例方法
  2.     @Test
  3.     public void test1(){
  4.         Consumer<String> con1 = str -> System.out.println(str);
  5.         con1.accept("beijing");
  7.         System.out.println();
  9.         PrintStream ps = System.out;
  10.         Consumer<String> con2 = ps :: println;
  11.         con2.accept("beijing");
  12.     }

类 :: 静态方法

  1. @Test
  2.     public void test2(){
  3.         Comparator<Integer> com1 = (t1,t2) -> Integer.compare(t1,t2);
  4.         System.out.println(com1.compare(12,21));
  6.         System.out.println();
  8.         Comparator<Integer> com2 = Integer::compare;
  9.         System.out.println(com2.compare(12, 3));
  10.     }

类 :: 非静态方法

  1. public void test3(){
  2.         Comparator<String> com1 = (s1,s2) -> s1.compareTo(s2);
  3.         System.out.println(com1.compare("abc", "abd"));
  5.         System.out.println();
  7.         Comparator<String> com2 = String :: compareTo;
  8.         System.out.println(com2.compare("abs","abm"));
  9.     }

要求

接口中的抽象方法的形参列表和返回值类型与方法引用的方法的形参列表和返回值类型相同（针对于前两种情况）

数组的引用

  1. @Test
  2.     public void test4(){
  3.         Function<Integer,String[]> fun1 = length -> new String[length];
  4.         String[] arr1 = fun1.apply(5);
  5.         System.out.println(Arrays.toString(arr1));
  7.         System.out.println();
  9.         Function<Integer,String[]> fun2 = String[] ::new;
  10.         String[] arr2 = fun2.apply(10);
  11.         System.out.println(Arrays.toString(arr2));
  12.     }

Stream API

屏幕截图 2022-04-20 212635.jpg
屏幕截图 2022-04-20 212844.jpg

实例化

  1. //创建Stream方式一：通过集合
  2.     @Test
  3.     public void test1(){
  4.         List<Employee> employees = EmployeeDate.getEmployees();
  5.         //default Stream<E> stream():返回一个顺序流
  6.         Stream<Employee> stream = employees.stream();
  8.         //default Stream<E> parallelStream():返回一个并行流
  9.         Stream<Employee> parallelStream = employees.parallelStream();
  11.     }
  13.     //创建Stream方式二：通过数组
  14.     @Test
  15.     public void test2(){
  16.         int[] arr = new int[]{1,2,3,4,5};
  17.         //调用Arrays类的static<T> Stream<T> stream(T[] array):返回一个流
  18.         IntStream stream = Arrays.stream(arr);
  19.         Employee e1 = new Employee(100,"Tom");
  20.         Employee e2 = new Employee(100,"Jerry");
  21.         Employee[] arr1 = new Employee[]{e1,e2};
  22.         Stream<Employee> stream1 = Arrays.stream(arr1);
  23.     }
  24.     //创建Stream方式三：通过Stream的of()
  25.     @Test
  26.     public void test3(){
  28.         Stream<Integer> stream = Stream.of(1,2,3,4);
  30.     }

中间操作

屏幕截图 2022-04-21 112939.jpg
屏幕截图 2022-04-21 113023.jpg
屏幕截图 2022-04-21 210958.jpg

终止操作

屏幕截图 2022-04-21 211304.jpg
屏幕截图 2022-04-21 211640.jpg
屏幕截图 2022-04-21 212023.jpg

Optional类

屏幕截图 2022-04-21 212711.jpg