Lambda表达式

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

格式:

  • -> lambda操作符h
  • 左 lambda形参列表
  • 右 lambda体

本质 作为接口的实例

如果一个接口中只声明了一个抽象方法，则此接口就称为函数式接口

用匿名实现类表示的方法现在都可以用Lambda表达式来写

使用

  • 无参 无返回值

    1. Runnable r1 = new Runnable() {
    2.   @Override
    3.   public void run() {
    4.       System.out.println("hello");
    5.   }
    6. };
    7. r1.run();
    8. //使用后
    9. Runnable r2 = () -> System.out.println("hello");
    10. r2.run();

  • 需要一个参数，但不需要返回值

    1.   @Test
    2.   public void ooo(){
    3.       Consumer<String> con = new Consumer<String>() {
    4.           @Override
    5.           public void accept(String s) {
    6.               System.out.println(s);
    7.           }
    8.       };
    9.       con.accept("hello,world!");
    11.       //使用后
    12.       Consumer<String> con2 = (String s) -> {
    13.           System.out.println(s);
    14.       };
    15.       con2.accept("hello,world!");
    17.   }
    18. }

  • 类型推断

    1. @Test
    2. public void oo(){
    3.   Consumer<String> con2 = (s) -> {
    4.       System.out.println(s);
    5.   };
    6.   con2.accept("hello,world!");
    7. }

  • Lambda只需要一个参数时 参数的小括号可以省略

    1. public void oo(){
    2.   Consumer<String> con2 = s -> {
    3.       System.out.println(s);
    4.   };
    5.   con2.accept("hello,world!");
    6. }

  • Lambda需要两个或以上的参数，多条执行语句，。并且可以有返回值

    1. @Test
    2. public void oooo(){
    3.   Comparator<Integer> con3 =(o1, o2) -> {
    4.       System.out.println(o1);
    5.       System.out.println(o2);
    6.       return o1.compareTo(o2);
    8.   };
    9. }

Java内置四大核心函数式接口

  • Consumer 消费型接口

    • void accept(T t)
      1. Consumer<String> con = (String s) -> {
      2. System.out.println(s);
      3. };
      4. con.accept("hello,world!");

  • Supplier 供给型接口

    • T get()
      1. Supplier<Integer> su = ()->{return 1;};
      2. Supplier<Integer> su1 = ()-> 1;
      3. System.out.println(su1.get());

  • Function 函数型接口

    • R apply(T t)
      1. Function<Integer, String> fun = (i) -> {
      2. return i + "";
      3. };
      4. Function<Integer, String> fun1 = i -> i + "";
      5. fun.apply(11);

  • Predicate 断定型接口

    • boolean test(T t) ```java Predicate pr = (i)->{ if (Integer.valueOf(1).equals(i)) {
      1. return false;
      } else {
      1. return true;
      } };

    System.out.println(pr.test(11)); ```

方法引用(Method Reference)

  • 当要传递给Lambda体的操作 ，已经有了实现的方法了，可以使用方法引用！
  • 即Lambda表达式深层次表达

  • 使用格式 类(对象)：方法名

    • 具体使用

    • 对象 :: 实例方法 ```java @Test public void ii(){ //lambda Consumer con1 =str -> System.out.println(str); con1.accept(“hello lambda”);

      //方法引用 PrintStream ps = System.out; Consumer con2 = ps::println; con2.accept(“hello method reference”);

}

  2.    - 类 :: 静态方法
  3. ```java
  4. //Comparator中的int compare(T t1,T t2)
  5. //Integer中的int compare(T t1,T t2)
  6. @Test
  7.     public void test3() {
  8.         Comparator<Integer> com1 = (t1,t2) -> Integer.compare(t1,t2);
  9.         System.out.println(com1.compare(12,21));
  11.         //method reference
  12.         Comparator<Integer> com2 = Integer::compare;
  13.         System.out.println(com2.compare(12,3));
  15.         Arrays.sort(array, String::compareTo);
  17.     }

  • 类 :: 非静态方法

    1. // Comparator中的int comapre(T t1,T t2)
    2. // String中的int t1.compareTo(t2)
    3. @Test
    4. public void test5() {
    5.    //lambda
    6.    Comparator<String> com1 = (s1,s2) -> s1.compareTo(s2);
    7.    System.out.println(com1.compare("abc","abd"));
    9.    //方法引用
    10.    Comparator<String> com2 = String :: compareTo;
    11.    System.out.println(com2.compare("abd","abm"));
    12. }

构造器引用

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

使用：

  1. @Test
  2.     public void test1(){
  4.         //normal
  5.         Supplier<Employee> sup = new Supplier<Employee>() {
  6.             @Override
  7.             public Employee get() {
  8.                 return new Employee();
  9.             }
  10.         };
  12.         //lambda
  13.         Supplier<Employee>  sup1 = () -> new Employee();
  14.         System.out.println(sup1.get());
  16.         //constructor conference
  17.         Supplier<Employee>  sup2 = Employee :: new;
  18.         System.out.println(sup2.get());
  19.     }

数组引用

写法与构造器引用一致。

  1. @Test
  2.     public void test4(){
  3.         Function<Integer,String[]> func1 = length -> new String[length];
  4.         String[] arr1 = func1.apply(5);
  5.         System.out.println(Arrays.toString(arr1));
  7.         //数组引用
  8.         Function<Integer,String[]> func2 = String[] :: new;
  9.         String[] arr2 = func2.apply(10);
  10.         System.out.println(Arrays.toString(arr2));
  12.     }