Java中lambda表达式学习

一.Lambda表达式的基础语法：

Java8中引入了一个新的操作符"->"该操作符称为箭头操作符或Lambda操作符，箭头操作符将Lambda表达式拆分为两部分：

左侧：Lambda表达式的参数列表

右侧：Lambda表达式所需要执行的功能，即Lambda体

语法一：无参数，无返回值

 () -> System.out.println("hello");

语法二：有一个参数，无返回值

 (x) -> System.out.println("hello" + x);

语法三：只有一个参数，无返回值

 x -> System.out.println("hello" + x);

语法四：有两个以上参数，又返回值，并且Lambda体中有多条语句

     Comparator<Interger> com = (x, y) -> {
         System.out.println("hello");
         return Interger.compare(x, y);
     };

语法五：如果Lambda体只有一条语句，return和大括号都可以省略

 Comparator<Interger> com = (x, y) -> Interger.compare(x, y);

语法六：Lambda表达式参数列表的数据类型可以省略不写，JVM编译器通过上下文推断出数据类型（“类型推断”）

 Comparator<Interger> com = (Interger x,Interger y) -> Interger.compare(x, y);

二.使用Lambda优化程序

接口->外部实现类->静态内部类->局部内部类->匿名内部类->lambda->方法引用方式

 /**
  * 定义一个函数式接口：
  * 函数式接口是一个接口中只有一个非默认且非Object类的方法
  */
 @FunctionalInterface
 interface ILike {
     //默认都为抽象方法（一般都省略abstract）
     void lambda();

     default void print() {
         System.out.println("我是默认方法");
     }

     String toString();

     boolean equals(Object obj);
 }

 //外部实现类
 class Like1 implements ILike {

     @Override
     public void lambda() {
         System.out.println("外部实现类");
     }
 }

 public class TestLambda {

     public static void printLambda() {
         System.out.println("我是TestLambda类的静态方法");
     }

     //静态内部类
     static class Like2 implements ILike {

         @Override
         public void lambda() {
             System.out.println("静态内部类");
         }
     }

     public static void main(String[] args) {

         ILike like = new Like1();
         like.lambda();

         like = new Like2();
         like.lambda();

         //局部内部类
         class Like3 implements ILike {

             @Override
             public void lambda() {
                 System.out.println("局部内部类");
             }
         }

         like = new Like3();
         like.lambda();

         //匿名内部类，没有类的名字，必须借助接口或者父类实现
         like = new ILike() {
             @Override
             public void lambda() {
                 System.out.println("匿名内部类");
             }
         };

         like.lambda();

         //lambda表达式
         like = () -> System.out.println("lambda表达式");
         like.lambda();

         //方法引用方式（类::静态方法）
         like = TestLambda::printLambda;
         like.lambda();

     }

 }

三.Lambda表达式的延迟执行

目的：避免性能浪费

字符串是否需要拼接用例：

• 普通方法：如果level不符合要求依旧会拼接字符串造成性能浪费
• lambda表达式：level不符合要求不会拼接，减少性能浪费
• 使用供给型接口优化lambda

 public class demo02Logger {

     public static void showLog1(int level, String message) {
         if (level == 1) {
             System.out.println("showLog1:level1:" + message);
         }
     }

     public static void showLog2(int level, MessageBuilder mb) {
         if (level == 1) {
             System.out.println("showLog2:level1:" + mb.builderMessage());
         }
     }

     public static void showLog3(int level, Supplier<String> stringSupplier) {
         if (level == 1) {
             System.out.println("showLog3:level1:" + stringSupplier.get());
         }
     }

     public static void main(String[] args) {
         String msg1 = "msg1";
         String msg2 = "msg2";
         String msg3 = "msg3";

         //普通方法：如果level不符合要求依旧会拼接字符串造成性能浪费
         showLog1(2, msg1 + msg2 + msg3);

         //lambda表达式：level不符合要求不会拼接，减少性能浪费
         showLog2(1, () -> {
             System.out.println("showLog2：level为1才执行拼接");
             return msg1 + msg2 + msg3;
         });

         showLog2(2, () -> {
             System.out.println("showLog2：level为2不执行拼接");
             return msg1 + msg2 + msg3;
         });

         //使用供给型函数式接口
         showLog3(1,() -> {
             System.out.println("showLog3：level为1才执行拼接");
             return msg1 + msg2 + msg3;
         });

         showLog3(2,() -> {
             System.out.println("showLog3：level为2不执行拼接");
             return msg1 + msg2 + msg3;
         });
     }
 }

 @FunctionalInterface
 interface MessageBuilder {
     String builderMessage();
 }

结果：

使用lambda优化了性能

 showLog2：level为1才执行
 showLog2:level1:msg1msg2msg3
 showLog3：level为1才执行
 showLog3:level1:msg1msg2msg3

四.Lambda表达式需要“函数式接口”的支持

函数式接口：接口中只有一个抽象的方法，称之为函数式接口。可以使用注解 @FunctionalInterface 修饰（用于检查是否是函数式接口）

Java8 内置的四大核心函数式接口：(还有很多子接口)

• Consumer<T>：消费型接口
  • void accept(T t);
• Supplier<T>：供给型接口
  • T get();

Function<T,R>：函数型接口（将T类型转换为R类型）

• R apply(T t);
• Predicate<T>：断言型接口
  • boolean test(T t)

1.方法引用：若Lambda体中的内容有方法已经实现了，我们可以使用“方法引用”（理解为Lambda的另一种表现形式）

主要有三种语法格式：（所引用的方法参数和返回值要与函数式接口的抽象方法参数和返回值一致）

• 对象::实例方法
• 类::静态方法
• 类::实例方法（必须是第一个参数为实例方法，调用者第二个参数为实例方法的参数）

 @Test
     public void test() {

         //lambda
         PrintStream ps = System.out;
         Consumer<String> con1 = (x) -> ps.println(x);
         con1.accept("con1");

         //对象::实例方法名（返回值和参数需要与方法调用者一致）
         Consumer<String> con2 = System.out::println;
         con2.accept("con2");

         //lambda
         Comparator<Integer> com1 = (x, y) -> Integer.compare(x, y);
         System.out.println(com1.compare(5, 6));

         //类::静态方法名（返回值和参数需要与方法调用者一致）
         Comparator<Integer> com2 = Integer::compare;
         System.out.println(com2.compare(5, 6));

         //lambda
         BiPredicate<String, String> bp1 = (x, y) -> x.equals(y);
         System.out.println(bp1.test("aaa","aaa"));

         //类::实例方法名（条件是第一个参数为实例方法调用者，第二个参数为实例方法的参数）
         // （返回值和参数需要与方法调用者一致）
         BiPredicate<String,String> bp2 = String::equals;
         System.out.println(bp2.test("aaa","aaa"));

     }

2.构造器引用：

格式：ClassName::new（所调用的构造器参数要与函数式接口的抽象方法参数一致）

     class Mytest{

         private Integer id;
         private String testmes;

         public Mytest() {
         }

         public Mytest(Integer id) {
             this.id = id;
         }

         public Mytest(Integer id, String testmes) {
             this.id = id;
             this.testmes = testmes;
         }

         @Override
         public String toString() {
             return "Mytest{" +
                     "id=" + id +
                     ", testmes='" + testmes + '\'' +
                     '}';
         }
     }

     @Test
     public void test2(){

         //Lambda(调用无参构造函数)
         Supplier<Mytest> sup1 = ()->new Mytest();
         System.out.println(sup1.get());

         //构造器引用方式(调用无参构造函数)
         Supplier<Mytest> sup2 = Mytest::new;
         System.out.println(sup2.get());

         //Lambda(调用一个参数和一个返回值构造函数)
         Function<Integer,Mytest> fun1 = (x)->new Mytest(x);
         System.out.println(fun1.apply(3));

         //构造器引用方式(调用一个参数和一个返回值构造函数)
         Function<Integer,Mytest> fun2 = Mytest::new;
         System.out.println(fun2.apply(3));

         //Lambda(调用两个参数和一个返回值构造函数)
         BiFunction<Integer,String,Mytest> bi1 = (x,y)->new Mytest(x,y);
         System.out.println(bi1.apply(3,"mytest3"));

         //构造器引用方式(调用两个参数和一个返回值构造函数)
         BiFunction<Integer,String,Mytest> bi2 = Mytest::new;
         System.out.println(bi2.apply(3,"mytest3"));

     }

3.数组引用

格式：Type::new

     @Test
     public void testarray(){

         //lambda
         Function<Integer,String[]> fun1 = (x) -> new String[x];
         System.out.println(fun1.apply(10).length);   //10

         //数组引用
         Function<Integer,String[]> fun2 = String[]::new;
         System.out.println(fun2.apply(15).length);  //15

     }