Lambda表达式

实例化接口(函数式接口)，重写接口抽象方法

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

package com.bobo.study.jdk.lambda;


import java.util.Comparator;
import java.util.function.Consumer;


import org.junit.Test;


public class LambdaTestUses {
  
  @Test
  public void test1() {
    
    System.out.println("========== 无参无返回值 ==========  \n");
    
    // 无参无返回值
    // 匿名内部类
    Runnable r1 = new Runnable() {
      @Override
      public void run() {
        System.out.println("匿名内部类 run方法");
      }
    };
    r1.run();
    
    System.out.println("---------- ---------- ");
    
    // lambda表达式 重写run()方法
    Runnable r2 = () -> {};
    Runnable r3 = () -> System.out.println("lambda表达式 run方法");
    new Thread(() -> System.out.println("lambda表达式 run方法")).start();
    r2.run();
    r3.run();
    
    // lambda表达式方法体多语句
    Runnable r4 = () -> {
      System.out.println("lambda表达式 run方法 1");
      System.out.println("lambda表达式 run方法 2");      
    };
    r4.run();
    
    
    System.out.println("\n========== 一个参数无返回值 ========== \n");
    
    // 一个参数无返回值
    // 匿名内部类
    Consumer<String> c1 = new Consumer<String>() {
      @Override
      public void accept(String t) {
        System.out.println("匿名内部类 accept方法  " + t);
      }
    };
    c1.accept("t");
    
    System.out.println("---------- ---------- ");
    
    // labmda表达式 重写 accept(String t)方法
    Consumer<String> c2 = (s) -> {System.out.println("lambda表达式 accept方法 " + s);};
    // labmda 简化
    Consumer<String> c3 = s -> System.out.println("lambda表达式 accept方法 " + s);
    c2.accept("b");
    c3.accept("c");
    
    System.out.println("\n========== 两个以上参数，多条执行语句，有返回值 ========== \n");
    
    Comparator<Integer> cr1 = new Comparator<Integer>() {
      @Override
      public int compare(Integer o1, Integer o2) {
        System.out.println("匿名内部类 o1 = " + o1);
        System.out.println("匿名内部类 o2 = " + o2);
        return Integer.compare(o1, o2);
      }
    };
    System.out.println("匿名内部类 比较结果 = " + cr1.compare(10, 20));
    
    System.out.println("---------- ---------- ");
    
    // lambda表达式 重写compare(T o1, T o2)方法
    // lambda 简化
    Comparator<Integer> cr2 = (o1, o2) -> Integer.compare(o1, o2);
    Comparator<Integer> cr3 = Integer::compare;
    System.out.println("lambda表达式 比较结果 = " + cr2.compare(30, 20));
    System.out.println("lambda表达式 比较结果 = " + cr3.compare(20, 20));
    
    Comparator<Integer> cr4 = (o1, o2) -> {
      System.out.println("lambda表达式 o1 = " + o1);
      System.out.println("lambda表达式 o2 = " + o2);
      return Integer.compare(o1, o2);
    };
    System.out.println("lambda表达式 比较结果 = " + cr4.compare(21, 20));
    
    System.out.println("\n========== ========== ========== \n");
  }


}

========== 无参无返回值 ==========  


匿名内部类 run方法
---------- ---------- 
lambda表达式 run方法
lambda表达式 run方法
lambda表达式 run方法 1
lambda表达式 run方法 2


========== 一个参数无返回值 ========== 


匿名内部类 accept方法  t
---------- ---------- 
lambda表达式 accept方法 b
lambda表达式 accept方法 c


========== 两个以上参数，多条执行语句，有返回值 ========== 


匿名内部类 o1 = 10
匿名内部类 o2 = 20
匿名内部类 比较结果 = -1
---------- ---------- 
lambda表达式 比较结果 = 1
lambda表达式 比较结果 = 0
lambda表达式 o1 = 21
lambda表达式 o2 = 20
lambda表达式 比较结果 = 1


========== ========== ========== 

->左边：lambda形参列表可以省略参数类型（类型推断），只有一个参数时，可以省略()
->右边：lambda使用{}包裹，只有一条语句时，可以省略{}和return；

匿名内部类可以对类、抽象类、接口进行实现；
lambda仅仅可以对接口进行实现；


匿名内部类对实现的抽象方法数量无限制；
lambda表达式可以实现仅存在一个抽象方法的接口；


匿名内部类是在编译时生成class文件
lambda表达式是在运行时生成class文件