1.1 Lambda表达式的语法
基本语法:
(parameters) -> expression 或 (parameters) ->{ statements; }
Lambda表达式由三部分构成：
- paramaters：类似方法中的形参列表，这里的参数是函数式接口里的参数。这里的参数类型可以明确的声明也可不声明而由JVM隐含的推断。另外当只有一个推断类型时可以省略掉圆括号。
- ->：可理解为“被用于”的意思
- 方法体：可以是表达式也可以代码块，是函数式接口里方法的实现。代码块可返回一个值或者什么都不反回，这里的代码块块等同于方法的方法体。假如是表达式，也可以返回一个值或者什么都不反回。
最经典的比如java中的forEach方法：
- import java.util.Arrays;
- import java.util.List;
- public class LambdaExample {
- public static void main(String[] args) {
- List<String> list = Arrays.asList('潘', '家', '辉', '别', '雪', '了');
-
- // Lambda表达式作为参数传递给forEach方法
- list.forEach(list -> System.out.print(list+" "));
- }
- }
要了解 Lambda 表达式 , 起首需要了解什么是函数式接口，
函数式接口定义：
一个接口有且只有一个抽象方法 。
注意：
- 假如一个接口只有一个抽象方法，那么该接口就是一个函数式接口
- 假如我们在某个接口上声明了 @FunctionalInterface 注解，那么编译器就会按照函数式接口的定义来要求该接口，如许假如有两个抽象方法，程序编译就会报错的。以是，从某种意义上来说，只要你保证你的接口中只有一个抽象方法，你可以不加这个注解。加上就会自动进行检测的。
-
-
- // 定义一个函数式接口
- @FunctionalInterface
- interface Task {
- //注意只能有一个方法
- void perform();
- }
-
- public class LambdaExample {
- public static void main(String[] args) {
- // 创建一个助手对象，使用Lambda表达式实现任务
- Task assistant = () -> System.out.println("助手正在切洋葱...");
-
- // 调用厨师的方法，传递助手对象执行任务
- cookMeal(assistant);
- }
-
- public static void cookMeal(Task task) {
- // 准备食材
- System.out.println("准备食材...");
-
- // 执行任务
- task.perform();
-
- // 煮菜
- System.out.println("开始烹饪...");
- }
- }
1.3 方法引用
先来看一下什么是方法引用：
方法引用着实是Lambda表达式的另一种写法，当要转达给Lambda体的操纵，已经有实现的方法了，可以使用方法引用；
注意： 实现抽象方法的参数列表，必须与方法引用方法的参数列表保持一致！
方法引用：使用操纵符::将方法名和对象或类的名字分隔开来，三种主要使用情况为
对象::实例方法
- import java.util.function.Consumer;
- public class MyTest {
- public static void main(String[] args) {
- Consumer<String> consumer = new Consumer<String>() {
- @Override
- public void accept(String s) {
- System.out.println(s);
- }
- };
- consumer.accept("aaaaaaaaaaaaaa");
- //aaaaaaaaaaaaaa
- //简写1：
- Consumer<String> consumer1 = (String s) -> {
- System.out.println(s);
- };
- consumer1.accept("abc");
- //abc
- //简写2：
- Consumer<String> consumer2 = (s) -> System.out.println(s);
- consumer2.accept("bcd");
- //bcd
- //简写3：
- Consumer<String> consumer3 = System.out::println;
- consumer3.accept("abc");
- //abc
- }
- }
- import java.util.function.BinaryOperator;
- public class MyTest1 {
- public static void main(String[] args) {
- BinaryOperator<Double> operator = new BinaryOperator<Double>(){
- @Override
- public Double apply(Double o, Double o2) {
- return Math.max(o,o2);
- }
- };
- System.out.println(operator.apply(2.13, 3.12));//3.12
- BinaryOperator<Double> operator2 = (o, o2) -> Math.max(o,o2);
- System.out.println(operator2.apply(2.13, 3.12));//3.12
- BinaryOperator<Double> operator3 = Math::max;
- Double max = operator3.apply(5.0, 20.0);
- System.out.println(max);//20.0
- }
- }
- import java.util.Comparator;
- public class MyTest2 {
- public static void main(String[] args) {
- Comparator<String> comparator = new Comparator<String>() {
- @Override
- public int compare(String o1, String o2) {
- return o1.compareTo(o2);
- }
- };
- System.out.println(comparator.compare("20", "12"));//1
- Comparator<String> comparator1 = String::compareTo;
- System.out.println(comparator1.compare("20", "12"));//1
- }
- }
格式：ClassName::new
与函数式接口相结合，自动与函数式接口中方法兼容。可以把构造器引用赋值给定义的方法，与构造器参数列表要与接口中抽象方法的参数列表一致！
- import java.util.function.Supplier;
- public class Mytest {
- public static void main(String[] args) {
- Supplier<Student> supplier = new Supplier<Student>() {
- @Override
- public Student get() {
- return new Student();
- }
- };
- Student student = supplier.get();
- Supplier<Student> supplier1 = () -> new Student();
- Student student1 = supplier1.get();
- }
- }
|
