项目总结41：Java8新特性之Lambda详解
写在前面：本文的整理基于尚硅谷Java8 新特性课程。前人栽树，后人乘凉。
1-Lambda表达式
为什么使用 Lambda 表达式
Lambda 是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使ava的语言表达能力得到了提升。
Lambda 表达式和匿名内部类之间的比较
@Test public void test1(){ //匿名内部类方式 Runnable runnable = new Runnable() { @Override public void run() { System.out.println("Anonymous inner class: hello world!"); } }; runnable.run();//Anonymous inner class: hello world! //lambda方式 Runnable lambdaRunnable = ()-> System.out.println("lambda runnable: hello world!"); lambdaRunnable.run();//lambda runnable: hello world! }
Lambda 表达式语法
Lambda 表达式：在Java 语言中引入了一个新的语法元素和操作符。这个操作符为 “->” ， 该操作符被称为 Lambda 操作符或剪头操作符。它将 Lambda 分为两个部分。左侧：指定了 Lambda 表达式需要的所有参数；右侧：指定了 Lambda 体，即 Lambda 表达式要执行的功能。
(1)语法格式一：无参，无返回值，Lambda 体只需一条语句
(2)语法格式二：有一个参数，并且无返回值
(3)语法格式三：若只有一个参数，小括号可以省略不写
(4)语法格式四：有两个以上的参数，有返回值，并且 Lambda 体中有多条语句
(4)语法格式五：若 Lambda 体中只有一条语句， return 和 大括号都可以省略不写 即：Comparator com = (x, y) -> Integer.compare(x, y);
(4)语法格式六：Lambda 表达式的参数列表的数据类型可以省略不写，因为JVM编译器通过上下文推断出，数据类型，即“类型推断”(Integer x, Integer y) -> Integer.compare(x, y);
@Test public void testLambdaSyntaxFormat(){ //语法格式一：无参数，无返回值 Runnable run = () -> System.out.println("hello world"); run.run(); //语法格式二：有一个参数，并且无返回值 Consumer<String> nameConsumer = (name) -> System.out.println("hello " + name); nameConsumer.accept("tyj"); //语法格式三：若只有一个参数，小括号可以省略不写 Consumer<Integer> ageConsumer = age -> System.out.println("my age is " + age); ageConsumer.accept(25); //语法格式四：有两个以上的参数，有返回值，并且 Lambda 体中有多条语句 Comparator<Integer> tComparator = (x, y) -> { System.out.println("x: " + x + " ; y: " + y); int compare = Integer.compare(x, y); return compare; }; int compare = tComparator.compare(2, 1); System.out.println("compare result: " + compare); //语法格式五：若 Lambda 体中只有一条语句， return 和 大括号都可以省略不写 即：Comparator com = (x, y) -> Integer.compare(x, y); Comparator<Integer> comA = (x,y)->Integer.compare(x,y); //语法格式六：Lambda 表达式的参数列表的数据类型可以省略不写，因为JVM编译器通过上下文推断出，数据类型，即“类型推断”(Integer x, Integer y) -> Integer.compare(x, y); Comparator<Integer> comB = (Integer x,Integer y)->Integer.compare(x,y); }
类型推断
上述 Lambda 表达式中的参数类型都是由编译器推断得出的。Lambda 表达式中无需指定类型，程序依然可以编译，这是因为 javac 根据程序的上下文，在后台推断出了参数的类型。Lambda 表达式的类型依赖于上下文环境，是由编译器推断出来的。这就是所谓的“类型推断”
2-函数式接口
只包含一个抽象方法的接口，称为函数式接口。
你可以通过 Lambda 表达式来创建该接口的对象。（若 Lambda 表达式抛出一个受检异常，那么该异常需要在目标接口的抽象方法上进行声明）。
我们可以在任意函数式接口上使用 @FunctionalInterface 注解，这样做可以检查它是否是一个函数式接口，同时 javadoc 也会包含一条声明，说明这个接口是一个函数式接口。
//函数式接口 @FunctionalInterface public interface MyFunc <T>{ public T getValue(T t); } ----------------------------------------------------------------------------------- //被调用的方法 public String toUpperString(MyFunc<String> mf, String str){ return mf.getValue(str); } //测试接口 @Test public void testCustom(){ String result = toUpperString((x)->x.toUpperCase(),"tyj"); //作为参数传递 Lambda 表达式：为了将 Lambda 表达式作为参数传递，接收Lambda 表达式的参数类型必须是与该 Lambda 表达式兼容的函数式接口的类型。 System.out.println("result: " + result);//result: TYJ }
Java 内置四大核心函数式接口
@Test public void testInterfaceType(){ //1- Supplier<T> Supplier<String> supplier = ()->"hello word".substring(0,5); System.out.println("supplier: " + supplier.get());//supplier: hello //2-Consumer<T> Consumer<Integer> consumer = (x) -> System.out.println("i am " + x); consumer.accept(25);//i am 25 //3-Function<T,R> Function<String,String> function = (String name) -> name.substring(0, 5); System.out.println("Function: " + function.apply("hello world"));//Function: hello //4-Predicate<T> Predicate<String> predicate = (name)-> name.length()> 1; System.out.println("predicate result: " + predicate.test("tyj"));//predicate result: true }
其他接口
3-方法引用与构造器引用
方法引用
当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！实现抽象方法的参数列表，必须与方法引用方法的参数列表保持一致！）方法引用：使用操作符 “::” 将方法名和对象或类的名字分隔开来。如下三种主要使用情况：
- 对象::实例方法
- 类::静态方法
- 类::实例方法
//对象 :: 实例方法名 @Test public void test1(){ //对象 :: 实例方法名 //Lambda表达式 Consumer<String> con = (x)-> System.out.println(x); con.accept("hello world"); //方法引用 PrintStream ps = System.out; Consumer<String> con1 = ps ::println; con1.accept("hello world2"); //简化一步为 Consumer<String> con2 = System.out :: println; con2.accept("hello world2"); } //对象 :: 实例方法名 @Test public void test2(){ Student stu = new Student("tyj",25); //Lambda Supplier<String> sup = ()-> stu.getName(); String name = sup.get(); System.out.println(name); //方法引用 Supplier<Integer> sup1 = stu :: getAge; Integer age = sup1.get(); System.out.println(age); } //类::静态方法名 @Test public void test3(){ //lambda Comparator<Integer> com = (x,y)->Integer.compare(x,y); int compare = com.compare(1, 2); System.out.println(compare); //方法引用 Comparator<Integer> com1 = Integer::compare; int compare1 = com1.compare(1, 2); System.out.println(compare1); } //类 :: 实例方法名 @Test public void test4(){ //Lambda BiPredicate<String,String> bp = (x,y)->x.equals(y); boolean test = bp.test("tyj", "tyj"); System.out.println(test); //方法引用 BiPredicate<String,String> bp1 = String ::equals; boolean test1 = bp1.test("tyj", "tyj"); System.out.println(test1); }
构造器引用
格式： ClassName::new
与函数式接口相结合，自动与函数式接口中方法兼容。可以把构造器引用赋值给定义的方法，与构造器参数列表要与接口中抽象方法的参数列表一致！
class Student{ String name; int age; public Student() { } public Student(String name) { this.name = name; } public Student(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public int getAge() { return age; } @Override public String toString() { return "Student{" + "name='" + name + '\'' + ", age=" + age + '}'; } } --------------------------------------------------------------------------------------- @Test public void test5(){ //构造函数没有参数 它适合Supplier签名 Supplier<Student> stu = Student::new; System.out.println(stu.get());//Student{name='null', age=0} //构造函数只有一个参数, 适合Function接口的签名 Function<String, Student> stu1 = Student::new; System.out.println(stu1.apply("tyj"));//Student{name='tyj', age=0} //构造函数有两个参数，那么就适合BiFunction接口的签名 BiFunction<String,Integer,Student> stu2 = Student::new; System.out.println(stu2.apply("tyj",25)); }