javajavase

Lambda表达式

Lambda是一个匿名函数，可以把Lambda表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）
使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升

使用Lambda表达式前后对比

  1. // 示例一：调用Runable接口
  2. @Test
  3. public void test1() {
  4.     Runnable r1 = new Runnable() {
  5.         @Override
  6.         public void run() {
  7.             System.out.println("我爱北京天安门");
  8.         }
  9.     };
  11.     r1.run();
  12.     System.out.println("***********************");
  14.     Runnable r2 = () -> System.out.println("我爱北京故宫");
  15.     r2.run();
  16. }
  1. // 示例二：使用Comparator接口
  2. @Test
  3. public void test2() {
  4.     // 匿名内部类
  5.     Comparator<Integer> com1 = new Comparator<Integer>() {
  6.         @Override
  7.         public int compare(Integer o1, Integer o2) {
  8.             return Integer.compare(o1,o2);
  9.         }
  10.     };
  12.     int compare1 = com1.compare(12,21);
  13.     System.out.println(compare1);
  14.     System.out.println("***********************");
  16.     // Lambda表达式的写法
  17.     Comparator<Integer> com2 = (o1,o2) -> Integer.compare(o1, o2);
  18.     int compare2 = com2.compare(32, 21);
  19.     System.out.println(compare2);
  20.     System.out.println("***********************");
  22.     // 方法引用
  23.     Comparator<Integer> com3 = Integer :: compare;
  24.     int compare3 = com3.compare(32,21);
  25.     System.out.println(compare3);
  26. }

Lamdba表达式基本语法

格式

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

Lamdba表达式使用（分为六种情况）
格式一：无参，无返回值

  1. Runnable r1 = () -> {System.out.println(“hello Lamdba!”);};

格式二：一个参数，无返回值

  1. Consumer<String> con = (String str) -> {System.out.println(str);};

格式三：数据类型可省略，因为可由编译器推断得出，称为类型推断

  • Lambda表达式中无需指定类型，程序依然可以编译，这是因为javac根据程序的上下文，在后台推断出了参数的类型

  • Lambda 表达式的类型依赖于上下文环境，是由编译器推断出来的。这就是所谓的“类型推断”

    1. Consumer<String> con = (str) -> {System.out.println(str);};

    格式四：Lamdba若只需要一个参数时，小括号可以省略

    1. Consumer<String> con = str -> {System.out.println(str);};

    格式五：两个以上的参数，多条执行语句，有返回值

    1. Comparator<Integer> com = (o1,o1) -> {
    2.   Syste.out.println("Lambda表达式使用");
    3.   return Integer.compare(o1,o2);
    4. }

    格式六：当Lamdba体只有一条语句时，return和大括号若有，都可以省略

    1. Comparator<Integer>com = (o1,o1) ->    Integer.compare(o1,o2);

    说明

  • ->左边：lambda形参列表的参数类型可以省略(类型推断)；如果lambda形参列表只有一个参数，其一对()也可以省略

  • ->右边：lambda体应该使用一对{ }包裹，如果lambda体只有一条执行语句（可能是return语句），省略这一对{ }和return关键字 ```java // 语法格式一：无参，无返回值 @Test public void test1() { Runnable r1 = new Runnable() {

    1.   @Override
    2.   public void run() {
    3.       System.out.println("我爱北京天安门");
    4.   }

    }; r1.run();

    System.out.println(“*“);

    Runnable r2 = () -> {

    1.   System.out.println("我爱北京故宫");

    }; r2.run(); }

// 语法格式二：Lambda 需要一个参数，但是没有返回值。 @Test public void test2() { Consumer con = new Consumer() { @Override public void accept(String s) { System.out.println(s); } }; con.accept(“谎言和誓言的区别是什么？”);

  1. System.out.println("*******************");
  3. Consumer<String> con1 = (String s) -> {
  4.     System.out.println(s);
  5. };
  6. con1.accept("一个是听得人当真了，一个是说的人当真了");

}

// 语法格式三：数据类型可以省略，因为可由编译器推断得出，称为“类型推断” @Test public void test3() { Consumer con1 = (String s) -> { System.out.println(s); }; con1.accept(“一个是听得人当真了，一个是说的人当真了”);

  1. System.out.println("*******************");
  3. Consumer<String> con2 = (s) -> {
  4.     System.out.println(s);
  5. };
  6. con2.accept("一个是听得人当真了，一个是说的人当真了");

}

@Test public void test4() { ArrayList list = new ArrayList<>(); // 类型推断 int[] arr = {1, 2, 3}; // 类型推断

}

// 语法格式四：Lambda 若只需要一个参数时，参数的小括号可以省略 @Test public void test5() { Consumer con1 = (s) -> { System.out.println(s); }; con1.accept(“一个是听得人当真了，一个是说的人当真了”);

  1. System.out.println("*******************");
  3. Consumer<String> con2 = s -> {
  4.     System.out.println(s);
  5. };
  6. con2.accept("一个是听得人当真了，一个是说的人当真了");

}

// 语法格式五：Lambda 需要两个或以上的参数，多条执行语句，并且可以有返回值 @Test public void test6() {

  1. Comparator<Integer> com1 = new Comparator<Integer>() {
  2.     @Override
  3.     public int compare(Integer o1, Integer o2) {
  4.         System.out.println(o1);
  5.         System.out.println(o2);
  6.         return o1.compareTo(o2);
  7.     }
  8. };
  9. System.out.println(com1.compare(12, 21));
  11. System.out.println("*****************************");
  13. Comparator<Integer> com2 = (o1, o2) -> {
  14.     System.out.println(o1);
  15.     System.out.println(o2);
  16.     return o1.compareTo(o2);
  17. };
  18. System.out.println(com2.compare(12, 6));

}

// 语法格式六：当 Lambda 体只有一条语句时，return 与大括号若有，都可以省略 @Test public void test7() { Comparator com1 = (o1, o2) -> { return o1.compareTo(o2); }; System.out.println(com1.compare(12, 6));

  1. System.out.println("*****************************");
  3. Comparator<Integer> com2 = (o1, o2) -> o1.compareTo(o2);
  4. System.out.println(com2.compare(12, 21));

}

@Test public void test8() { Consumer con1 = s -> { System.out.println(s); }; con1.accept(“一个是听得人当真了，一个是说的人当真了”);

  1. System.out.println("*****************************");
  3. Consumer<String> con2 = s -> System.out.println(s);
  4. con2.accept("一个是听得人当真了，一个是说的人当真了");

}

  2. ---
  4. <a name="h2_9"></a>
  5. ## 函数式接口
  6. **概述**<br />只包含一个抽象方法的接口，称为函数式接口
  8. - 可以通过 Lambda 表达式来创建该接口的对象。（若Lambda表达式抛出一个受检异常，该异常需要在目标接口的抽象方法上进行声明）
  9. - 可以在一个接口上使用 @FunctionalInterface 注解，这样做可以检查它是否是一个函数式接口。同时javadoc也会包含一条声明，说明这个接口是一个函数式接口
  10. - Lambda表达式的本质：**作为函数式接口的实例，**当需要对一个函数式接口实例化的时候，可以使用Lambda表达式
  11. - 在 **java.util.function **包下定义了Java 8的丰富的函数式接口
  13. **自定义函数式接口**
  14. ```java
  15. @FunctionalInterface
  16. public interface MyInterface {
  17.     void method();
  18. }

如何理解函数式接口

  • Java从诞生日起就是一直倡导“一切皆对象”，在Java里面面向对象编程(OOP)是一切。但是随着python、scala等语言的兴起和新技术的挑战，Java不得不做出调整以便支持更加广泛的技术要求，也即java不但可以支持OOP还可以支持OOF（面向函数编程）
  • 在函数式编程语言当中，函数被当做一等公民对待。在将函数作为一等公民的编程语言中，Lambda表达式的类型是函数。但在Java 8中，Lambda表达式是对象，而不是函数，它们必须依附于一类特别的对象类型——函数式接口
  • 简单的说，在Java 8中，Lambda表达式就是一个函数式接口的实例，这就是Lambda表达式和函数式接口的关系。也就是说，只要一个对象是函数式接口的实例，那么该对象就可以用Lambda表达式来表示
  • 所以以前用匿名实现类表示的现在都可以用Lambda表达式来写

  • 如果我们开发中需要定义一个函数式接口，首先看看在已有的JDK提供的函数式接口是否提供了能满足需求的函数式接口。如果有，则直接调用即可，不需要自己再自定义了

    Java内置函数式接口

    四大核心函数式接口

    Lambda、函数式接口、方法引用 - 图1 ```java @Test public void test1() { happyTime(500, new Consumer() {

    1.   @Override
    2.   public void accept(Double aDouble) {
    3.       System.out.println("学习太累了，去天上人间买了瓶矿泉水，价格为：" + aDouble);
    4.   }

    });

    System.out.println(“**“);

    happyTime(400, money -> System.out.println(“学习太累了，去天上人间喝了口水，价格为：”

    1.                                          + money));

    }

public void happyTime(double money, Consumer con) { con.accept(money); }

@Test public void test2() { List list = Arrays.asList(“北京”, “南京”, “天津”, “东京”, “西京”, “普京”);

  1. List<String> filterStrs = filterString(list, new Predicate<String>() {
  2.     @Override
  3.     public boolean test(String s) {
  4.         return s.contains("京");
  5.     }
  6. });
  7. System.out.println(filterStrs);
  9. List<String> filterStrs1 = filterString(list, s -> s.contains("京"));
  10. System.out.println(filterStrs1);

}

// 根据给定的规则，过滤集合中的字符串。此规则由Predicate的方法决定 public List filterString(List list, Predicate pre) { ArrayList filterList = new ArrayList<>();

  1. for (String s : list) {
  2.     if (pre.test(s)) {
  3.         filterList.add(s);
  4.     }
  5. }
  6. return filterList;

}

  1. <a name="vqghW"></a>
  2. #### 其他函数式接口
  3. ![](https://cdn.nlark.com/yuque/0/2020/png/1379492/1591028998099-a00a66c7-c813-4a7e-a1d7-e7e881c7668c.png#id=twiUG&margin=%5Bobject%20Object%5D&originHeight=706&originWidth=1304&originalType=binary&ratio=1&size=0&status=done&style=shadow)
  5. ---
  7. <a name="h2_15"></a>
  8. ## 方法的引用
  9. **概述**
  11. - 方法引用可以看做是Lambda表达式深层次的表达。换句话说，方法引用就是Lambda表达式，也就是函数式接口的一个实例，通过方法的名字来指向一个方法
  13. **使用情景**
  15. - **当要传递给Lambda体的操作，已经实现的方法了，可以使用方法引用**
  17. **使用格式**<br />类(或对象) :: 方法名<br />**分类**<br />`**对象 :: 非静态方法**`<br />`**类 :: 静态方法**`<br />`**类 :: 非静态方法**`<br />**使用要求**
  19. - 要求接口中的抽象方法的形参列表和返回值类型与方法引用的方法的形参列表和返回值类型相同（针对于情况**1**和情况**2**）
  20. - 当函数式接口方法的第一个参数是需要引用方法的调用者，并且第二个参数是需要引用方法的参数(或无参数)时，ClassName::methodName（针对于情况**3**）
  22. **使用建议**<br />如果给函数式接口提供实例，恰好满足方法引用的使用情境，就可以考虑使用方法引用给函数式接口提供实例。如果不熟悉方法引用，那么还可以使用lambda表达式
  23. ```java
  24. // 情况一： 对象 :: 实例方法
  25. // Consumer中的void accept(T t)
  26. // PrintStream中的void println(T t)
  27. @Test
  28. public void test1() {
  29.     Consumer<String> con1 = str -> System.out.println(str);
  30.     con1.accept("北京");
  32.     System.out.println("*******************");
  34.     PrintStream ps = System.out;
  35.     Consumer<String> con2 = ps::println;
  36.     con2.accept("beijing");
  37. }
  39. // Supplier中的T get()
  40. // Employee中的String getName()
  41. @Test
  42. public void test2() {
  43.     Employee emp = new Employee(1001, "Tom", 23, 5600);
  45.     Supplier<String> sup1 = () -> emp.getName();
  46.     System.out.println(sup1.get());
  48.     System.out.println("*******************");
  49.     Supplier<String> sup2 = emp::getName;
  50.     System.out.println(sup2.get());
  51. }
  53. // 情况二：类 :: 静态方法
  54. // Comparator中的int compare(T t1, T t2)
  55. // Integer中的int compare(T t1, T t2)
  56. @Test
  57. public void test3() {
  58.     Comparator<Integer> com1 = (t1, t2) -> Integer.compare(t1, t2);
  59.     System.out.println(com1.compare(12, 21));
  61.     System.out.println("*******************");
  63.     Comparator<Integer> com2 = Integer::compare;
  64.     System.out.println(com2.compare(12, 3));
  65. }
  67. // Function中的R apply(T t)
  68. // Math中的Long round(Double d)
  69. @Test
  70. public void test4() {
  71.     Function<Double, Long> func = new Function<Double, Long>() {
  72.         @Override
  73.         public Long apply(Double d) {
  74.             return Math.round(d);
  75.         }
  76.     };
  78.     System.out.println("*******************");
  80.     Function<Double, Long> func1 = d -> Math.round(d);
  81.     System.out.println(func1.apply(12.3));
  83.     System.out.println("*******************");
  85.     Function<Double, Long> func2 = Math::round;
  86.     System.out.println(func2.apply(12.6));
  87. }
  89. // 情况三：类 :: 实例方法  (有难度)
  90. // Comparator中的int comapre(T t1,T t2)
  91. // String中的int t1.compareTo(t2)
  92. @Test
  93. public void test5() {
  94.     Comparator<String> com1 = (s1, s2) -> s1.compareTo(s2);
  95.     System.out.println(com1.compare("abc", "abd"));
  97.     System.out.println("*******************");
  99.     Comparator<String> com2 = String::compareTo;
  100.     System.out.println(com2.compare("abd", "abm"));
  101. }
  103. // BiPredicate中的boolean test(T t1, T t2);
  104. // String中的boolean t1.equals(t2)
  105. @Test
  106. public void test6() {
  107.     BiPredicate<String, String> pre1 = (s1, s2) -> s1.equals(s2);
  108.     System.out.println(pre1.test("abc", "abc"));
  110.     System.out.println("*******************");
  111.     BiPredicate<String, String> pre2 = String::equals;
  112.     System.out.println(pre2.test("abc", "abd"));
  113. }
  115. // Function中的R apply(T t)
  116. // Employee中的String getName();
  117. @Test
  118. public void test7() {
  119.     Employee employee = new Employee(1001, "Jerry", 23, 6000);
  121.     Function<Employee, String> func1 = e -> e.getName();
  122.     System.out.println(func1.apply(employee));
  124.     System.out.println("*******************");
  126.     Function<Employee, String> func2 = Employee::getName;
  127.     System.out.println(func2.apply(employee));
  128. }

构造器和数组的引用

格式
构造器引用 **类名::new**
数组引用 **数组类型[]::new**
使用要求

  • 构造器引用

和方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致。抽象方法的返回值类型即为构造器所属的类的类型

  • 数组引用

可以把数组看做是一个特殊的类，则写法与构造器引用一致
使用举例

  • 构造器引用 ```java // Supplier中的T get() // Employee的空参构造器：Employee() @Test public void test1() { Supplier sup = new Supplier() {

    1.   @Override
    2.   public Employee get() {
    3.       return new Employee();
    4.   }

    }; System.out.println(“*“);

    Supplier sup1 = () -> new Employee(); System.out.println(sup1.get());

    System.out.println(“*“);

    Supplier sup2 = Employee :: new; System.out.println(sup2.get()); }

// Function中的R apply(T t) @Test public void test2() { Function func1 = id -> new Employee(id); Employee employee = func1.apply(1001); System.out.println(employee);

  1. System.out.println("*******************");
  3. Function<Integer,Employee> func2 = Employee :: new;
  4. Employee employee2 = func2.apply(1002);
  5. System.out.println(employee2);

}

// BiFunction中的R apply(T t,U u) @Test public void test3(){ BiFunction func1 = (id,name) -> new Employee(id, name); System.out.println(func1.apply(1001,”Tom”));

  1. System.out.println("*******************");
  3. BiFunction<Integer,String,Employee> func2 = Employee :: new;
  4. System.out.println(func2.apply(1002,"Jerry"));

}

  2. - **数组引用**
  3. ```java
  4. // Function中的R apply(T t)
  5. @Test
  6. public void test4() {
  7.     Function<Integer,String[]> func1 = length -> new String[length];
  8.     String[] arr1 = func1.apply(5);
  9.     System.out.println(Arrays.toString(arr1));
  11.     System.out.println("*******************");
  13.     Function<Integer,String[]> func2 = String[] :: new;
  14.     String[] arr2 = func2.apply(10);
  15.     System.out.println(Arrays.toString(arr2));
  16. }