1、Java8的lambda表达式，通过lambda表达式可以替代我们之前写的匿名内部类来实现接口。lambda表达式本质是一个匿名函数。
1 package com.demo.main; 2 3 public class LambdaMain { 4 5 public static void main(String[] args) { 6 7 // 1、创建一个匿名内部类 8 Addition addition = new Addition() { 9 10 @Override 11 public int add(int a, int b) { 12 13 return a + b; 14 } 15 16 }; 17 // 传统的匿名内部类来实现接口。 18 System.out.println("调用匿名内部类来实现接口：" + addition.add(2, 3)); 19 20 // 2、Java8的lambda表达式，通过lambda表达式可以替代我们之前写的匿名内部类来实现接口。 21 // lambda表达式本质是一个匿名函数。 22 // 2.1、lambda由三部分组成，()是参数列表，->剪头符号，{}代表方法体。 23 Addition a2 = (int a, int b) -> { 24 return a + b; 25 }; 26 System.out.println("lambda表达式a2：" + a2.add(3, 3)); 27 28 // 2.2、可以省略参数列表里面的参数类型 29 Addition a3 = (a, b) -> { 30 return a + b; 31 }; 32 System.out.println("lambda表达式a3：" + a3.add(3, 3)); 33 34 } 35 36 /** 37 * 38 * @author 创建一个接口，定义一个方法 39 * 40 */ 41 interface Addition { 42 43 /** 44 * 加法的方法 45 * 46 * @param a 47 * @param b 48 * @return 49 */ 50 int add(int a, int b); 51 } 52 53 }
2、Lambda表达式语法，形如(int a, int b) -> {return a + b;}，lambda本质就是一个（匿名）函数，匿名函数，就是没有方法名称的函数。
1 一般函数结构类似，如下所示： 2 int add(int a, int b){ 3 return a + b; 4 } 5 6 一般函数的，结构如：返回值 方法名称(参数列表) 方法体。
3、而Lamdba表达式函数，只有参数列表和方法体。结构如：(参数列表) -> {方法体};
详细说明，如下所示：
1）、()括号用来描述参数列表。
2）、{}大括号用来描述方法体。
3）、->尖括号，Lambda运算符，可以叫做箭头符号，或者goes to。
4、Lambda表达式语法，关于接口方法参数、无参、单个参数、两个参数、有返回值、没有返回值的情况。如何来根据lambda来返回接口函数。
1 package com.demo.main; 2 3 public class LambdaMain { 4 5 public static void main(String[] args) { 6 // 1、无参数无返回值 7 MethodNoReturnNoParam methodNoReturnNoParam = () -> { 8 System.out.println("无参数无返回值"); 9 }; 10 methodNoReturnNoParam.lambda1(); 11 12 // 2、单个参数无返回值 13 MethodNoReturnOneParam methodNoReturnOneParam = (int a) -> { 14 System.out.println("单个参数无返回值,a = " + a); 15 }; 16 methodNoReturnOneParam.lambda2(3); 17 18 // 3、两个参数无返回值 19 MethodNoReturnTwoParam methodNoReturnTwoParam = (int a, int b) -> { 20 System.out.println("两个参数无返回值,a + b = " + (a + b)); 21 }; 22 methodNoReturnTwoParam.lambda3(3, 4); 23 24 // 4、无参数有返回值 25 MethodReturnNoParam methodReturnNoParam = () -> { 26 return 8; 27 }; 28 System.out.println("无参数有返回值:" + methodReturnNoParam.lambda4()); 29 30 // 5、一个参数有返回值 31 MethodReturnOneParam methodReturnOneParam = (int a) -> { 32 return a; 33 }; 34 System.out.println("一个参数有返回值,a = " + methodReturnOneParam.lambda5(9)); 35 36 // 6、一个参数有返回值 37 MethodReturnTwoParam methodReturnTwoParam = (int a, int b) -> { 38 return a + b; 39 }; 40 System.out.println("一个参数有返回值,a + b = " + methodReturnTwoParam.lambda6(9, 9)); 41 42 } 43 44 /** 45 * 1、无参数无返回值 46 * 47 * @author 48 * 49 */ 50 interface MethodNoReturnNoParam { 51 52 void lambda1(); 53 } 54 55 /** 56 * 2、单个参数无返回值 57 * 58 * @author 59 * 60 */ 61 interface MethodNoReturnOneParam { 62 63 void lambda2(int a); 64 } 65 66 /** 67 * 3、两个参数无返回值 68 * 69 * @author 70 * 71 */ 72 interface MethodNoReturnTwoParam { 73 74 void lambda3(int a, int b); 75 } 76 77 /** 78 * 4、无参数有返回值 79 * 80 * @author 81 * 82 */ 83 interface MethodReturnNoParam { 84 85 int lambda4(); 86 } 87 88 /** 89 * 5、一个参数有返回值 90 * 91 * @author 92 * 93 */ 94 interface MethodReturnOneParam { 95 96 int lambda5(int a); 97 } 98 99 /** 100 * 6、两个参数有返回值 101 * 102 * @author 103 * 104 */ 105 interface MethodReturnTwoParam { 106 107 int lambda6(int a, int b); 108 } 109 110 }
5、Lambda表达式语法，精简写法，如下所示：
1）、参数类型可以省略。
2）、假如只有一个参数，()括号可以省略。
3）、如果方法体只有一条语句，{}大括号可以省略。
4）、如果方法体中唯一的语句是return返回语句，那省略大括号的同时return关键词也要省略掉。
1 package com.demo.main; 2 3 public class LambdaMain { 4 5 public static void main(String[] args) { 6 // 1、无参数无返回值 7 MethodNoReturnNoParam methodNoReturnNoParam = () -> System.out.println("无参数无返回值"); 8 methodNoReturnNoParam.lambda1(); 9 10 // 2、单个参数无返回值 11 MethodNoReturnOneParam methodNoReturnOneParam = a -> System.out.println("单个参数无返回值,a = " + a); 12 methodNoReturnOneParam.lambda2(3); 13 14 // 3、两个参数无返回值 15 MethodNoReturnTwoParam methodNoReturnTwoParam = (a, b) -> System.out.println("两个参数无返回值,a + b = " + (a + b)); 16 methodNoReturnTwoParam.lambda3(3, 4); 17 18 // 4、无参数有返回值 19 MethodReturnNoParam methodReturnNoParam = () -> 8; 20 System.out.println("无参数有返回值:" + methodReturnNoParam.lambda4()); 21 22 // 5、一个参数有返回值 23 MethodReturnOneParam methodReturnOneParam = a -> a + 10; 24 System.out.println("一个参数有返回值,a = " + methodReturnOneParam.lambda5(9)); 25 26 // 6、一个参数有返回值 27 MethodReturnTwoParam methodReturnTwoParam = (a, b) -> a + b; 28 System.out.println("一个参数有返回值,a + b = " + methodReturnTwoParam.lambda6(9, 9)); 29 30 } 31 32 /** 33 * 1、无参数无返回值 34 * 35 * @author 36 * 37 */ 38 interface MethodNoReturnNoParam { 39 40 void lambda1(); 41 } 42 43 /** 44 * 2、单个参数无返回值 45 * 46 * @author 47 * 48 */ 49 interface MethodNoReturnOneParam { 50 51 void lambda2(int a); 52 } 53 54 /** 55 * 3、两个参数无返回值 56 * 57 * @author 58 * 59 */ 60 interface MethodNoReturnTwoParam { 61 62 void lambda3(int a, int b); 63 } 64 65 /** 66 * 4、无参数有返回值 67 * 68 * @author 69 * 70 */ 71 interface MethodReturnNoParam { 72 73 int lambda4(); 74 } 75 76 /** 77 * 5、一个参数有返回值 78 * 79 * @author 80 * 81 */ 82 interface MethodReturnOneParam { 83 84 int lambda5(int a); 85 } 86 87 /** 88 * 6、两个参数有返回值 89 * 90 * @author 91 * 92 */ 93 interface MethodReturnTwoParam { 94 95 int lambda6(int a, int b); 96 } 97 98 }
6、方法引用，如果多个lamdba表达式实现函数都是一样的话，可以封装成通用方法，以方便维护，此时可以使用方法引用实现。
语法规则：对象::方法。假如是static静态方法，可以直接类名::方法。
1 package com.demo.main; 2 3 public class LambdaMain { 4 5 public static void main(String[] args) { 6 // // 创建对象 7 // LambdaMain lambdaMain = new LambdaMain(); 8 // // 采用对象引用的方式进行实现 9 // MethodReturnOneParam methodReturnOneParam_1 = lambdaMain::add; 10 // System.out.println(methodReturnOneParam_1.lambda5(10)); 11 // 12 // // 采用对象引用的方式进行实现 13 // MethodReturnOneParam methodReturnOneParam_2 = lambdaMain::add; 14 // System.out.println(methodReturnOneParam_2.lambda5(40)); 15 16 17 // 创建对象 18 // 采用静态对象引用的方式进行实现 19 MethodReturnOneParam methodReturnOneParam_1 = LambdaMain::addStatic; 20 System.out.println(methodReturnOneParam_1.lambda5(10)); 21 22 // 采用静态对象引用的方式进行实现 23 MethodReturnOneParam methodReturnOneParam_2 = LambdaMain::addStatic; 24 System.out.println(methodReturnOneParam_2.lambda5(40)); 25 } 26 27 /** 28 * 方法引用，如果多个lamdba表达式实现函数都是一样的话，可以封装成通用方法，以方便维护，此时可以使用方法引用实现。 29 * 30 * @param a 31 * @return 32 */ 33 public int add(int a) { 34 return a + 10; 35 } 36 37 /** 38 * 静态方法引用 39 * 40 * @param a 41 * @return 42 */ 43 public static int addStatic(int a) { 44 return a + 10; 45 } 46 47 /** 48 * 5、一个参数有返回值 49 * 50 * @author 51 * 52 */ 53 interface MethodReturnOneParam { 54 55 int lambda5(int a); 56 } 57 58 }
7、构造方法引用，如果函数式接口的实现切好可以通过调用一个类的构造方法来实现，那么就可以使用构造方法引用。
语法规则：类名::new。
1 package com.demo.po; 2 3 public class Dog { 4 5 private String name; 6 private int age; 7 8 public String getName() { 9 return name; 10 } 11 12 public void setName(String name) { 13 this.name = name; 14 } 15 16 public int getAge() { 17 return age; 18 } 19 20 public void setAge(int age) { 21 this.age = age; 22 } 23 24 @Override 25 public String toString() { 26 return "Dog [name=" + name + ", age=" + age + "]"; 27 } 28 29 public Dog(String name, int age) { 30 System.out.println("含参构造函数！"); 31 this.name = name; 32 this.age = age; 33 } 34 35 public Dog() { 36 System.out.println("无参构造函数！"); 37 } 38 39 }
1 package com.demo.main; 2 3 import com.demo.po.Dog; 4 5 public class LambdaMain { 6 7 public static void main(String[] args) { 8 // 1、使用lambda表达式的方式使用 9 DogService dogService1_0 = () -> { 10 return new Dog(); 11 }; 12 dogService1_0.getDog(); 13 14 // 2、简化方式 15 DogService dogService1_1 = () -> new Dog(); 16 dogService1_1.getDog(); 17 18 // 3、构造方法引用，如果函数式接口的实现切好可以通过调用一个类的构造方法来实现，那么就可以使用构造方法引用。 19 DogService dogService1_2 = Dog::new; 20 dogService1_2.getDog(); 21 22 // 4、构造方法引用，有参构造函数调用 23 DogService2 dogService2_1 = Dog::new; 24 dogService2_1.getDog("小黄", 2); 25 26 } 27 28 interface DogService { 29 30 /** 31 * 获取到一只无名狗 32 * 33 * @return 34 */ 35 Dog getDog(); 36 } 37 38 interface DogService2 { 39 40 /** 41 * 获取到一个有名称的狗 42 * 43 * @param name 44 * @param age 45 * @return 46 */ 47 Dog getDog(String name, int age); 48 } 49 50 }
8、集合使用lambda表达式对数据进行排序，遍历等操作。对于参数是接口函数的方法，需要传递lamdba表达式作为参数进行调用。
1 package com.demo.main; 2 3 import java.util.ArrayList; 4 import java.util.List; 5 6 import com.demo.po.Dog; 7 8 public class LambdaMain { 9 10 public static void main(String[] args) { 11 List<Dog> list = new ArrayList<Dog>(); 12 list.add(new Dog("小黄", 5)); 13 list.add(new Dog("小花", 4)); 14 list.add(new Dog("旺财", 3)); 15 list.add(new Dog("团团", 2)); 16 list.add(new Dog("圆圆", 1)); 17 18 // 排序 19 System.out.println("lambda集合排序!!!"); 20 // sort的参数是接口函数，需要使用lambda表达式匿名函数形式 21 list.sort((dog1, dog2) -> dog1.getAge() - dog2.getAge()); 22 System.out.println(list); 23 System.out.println(); 24 25 // 遍历集合 26 System.out.println("lamdba集合遍历："); 27 list.forEach(System.out::println); 28 } 29 30 }
9、@FunctionalInterface注解，此注解是函数式接口注解，所谓的函数式接口，当然首先是一个接口，然后就是在这个接口里面只能有一个抽象方法。这种类型的接口也称为SAM接口，即Single Abstract Method interfaces。
特点：
1）、接口有且仅有一个抽象方法。
2）、运行定义静态方法。
3）、允许定义默认方法。
4）、允许java.lang.Object中的public方法。
5）、该注解不是必须的，如果一个接口符合"函数式接口"定义，那么加不加该注解都没有影响。加上该注解能够更好的让编译器进行检查。如果编写的不是函数时接口，但是加上该注解，那么编译器会报错。
1 package com.demo.main; 2 3 public class LambdaMain { 4 5 public static void main(String[] args) { 6 FunctionInterface functionInterface = (int a) -> { 7 System.out.println("a = " + a); 8 }; 9 functionInterface.add(10); 10 } 11 12 /** 13 * 正确的函数式接口 14 * 15 * @author biexiansheng 16 * 17 */ 18 @FunctionalInterface 19 interface FunctionInterface { 20 21 /** 22 * 抽象方法 23 */ 24 public void add(int a); 25 26 /** 27 * java.lang.Object中的public方法 28 * 29 * @param var 30 * @return 31 */ 32 public boolean equals(Object var); 33 34 // 默认的方法 35 public default void defaultMethod() { 36 System.out.println("默认的方法！！！"); 37 } 38 39 // 静态方法 40 public static void staticMethod() { 41 System.out.println("静态的方法！！！"); 42 } 43 44 } 45 46 }
10、系统内置函数式接口，Java8的推出，是以lamdba重要特性，一起推出的，其中系统内置了一系列函数式接口。在jdk的java.util.function包下，有一系列的内置函数式接口：
1 package com.demo.main; 2 3 import java.util.function.IntConsumer; 4 import java.util.function.IntFunction; 5 import java.util.function.IntPredicate; 6 7 public class LambdaMain { 8 9 public static void main(String[] args) { 10 // 在jdk的java.util.function包下，有一系列的内置函数式接口 11 // 1、使用int函数接口 12 IntFunction<Integer> intFunction = (a) -> { 13 return a + 10; 14 }; 15 System.out.println(intFunction.apply(20)); 16 17 // 2、使用int判断函数接口 18 final int aa = 20; 19 IntPredicate intPredicate = (a) -> { 20 return a == aa; 21 }; 22 System.out.println(intPredicate.test(aa)); 23 24 // 3、使用int传递参数的形式 25 IntConsumer intConsumer = (a) -> { 26 System.out.println("a = " + a); 27 }; 28 intConsumer.accept(20); 29 30 // 书写技巧：首先定义一个接口函数对象，然后后面跟lambda表达式。 31 // lambda参数列表根据接口函数的方法参数类型和参数个数。 32 // lambda的方法体，是否有返回值，根据接口函数的方法是否有返回值。 33 } 34 35 }