Lambda表达式是一个可传递的代码块,可以在以后执行一次或多次;
下面贴个对比代码:
123456789101112131415 | // Java8之前:旧的写法Runnable runnable = new Runnable() { @Override public void run() { System.out.println("old run"); }};Thread t = new Thread(runnable);// Java8之后:新的写法Runnable runnable1 = ()->{ System.out.println("lambda run");};Thread t1 = new Thread(runnable1); |
---|
可以看到,有了lambda,代码变得简洁多了
你可以把lambda当作一个语法糖
下面让我们一起来探索lambda的美好世界吧
下面列出本文的目录
下面分别说下语法中的三个组成部分
参数:
1 | ( Dog dog ) |
---|
Comparator<String> comparatorTest = (a, b)->a.length()-b.length();
,可以推导出a,b都为String符号: ->
主体:
1 | { System.out.println("javalover"); } |
---|
{;}
(比如上图所示)a.length()- b.length()
)为了简化代码
因为Java是面向对象语言,所以在lambda出现之前,我们需要先构造一个对象,然后在对象的方法中实现具体的内容,再把构造的对象传递给某个对象或方法
但是有了lambda以后,我们可以直接将代码块传递给对象或方法
现在再回头看下开头的例子
可以看到,用了lambda表达式后,少了很多模板代码,只剩下一个代码块(最核心的部分)
就是只定义了一个抽象方法的接口
1234567891011 | @FunctionalInterfacepublic interface FunctionInterfaceDemo { void abstractFun(); default void fun1(){ System.out.println("fun1"); } default void fun2(){ System.out.println("fun2"); } } |
---|
这里的注解@FunctionalInterface可以省略,但是建议加上,就是为了告诉编译器,这是一个函数式接口,此时如果该接口有多个抽象方法,那么编译器就会报错
123456 | // 编译器会报错,Multiple non-overriding abstract methods found in XXX@FunctionalInterfacepublic interface NoFunctionInterfaceDemo extends FunctionInterfaceDemo{ void abstractFun2();} |
---|
上面的父接口FunctionInterfaceDemo中已经有了一个抽象方法,此时NoFunctionInterfaceDemo又定义了一个抽象方法,结果编译器就提示了:存在多个抽象方法
在Java8之前,其实我们已经接触过函数式接口
比如Runnable 和 Comparable
只是没有注解@FunctionalInterface。
那这个函数式接口要怎么用呢?
配合lambda食用,效果最佳(就是把lambda传递给函数式接口),示例代码如下:
12 | new Thread(() -> System.out.println("run")).start();复制代码 |
---|
其中用到的函数式接口是Runnable
就是把行为定义成参数,行为就是函数式接口
类似泛型中的类型参数化<T>
,类型参数化是把类型定义成参数
行为参数化,通俗点来说:
这样来看的话,行为参数化和设计模式中的策略模式有点像了(后面章节会分别讲常用的几种设计模式)
下面我们手写一个函数式接口来加深理解吧
下面我们循序渐进,先从简单的需求开始
12345678 | public static String processFile() throws IOException { // Java7新增的语法,try(){},可自动关闭资源,减少了代码的臃肿 try( BufferedReader bufferedReader = new BufferedReader(new FileReader("D:\\JavaProject\\JavaBasicDemo\\test.txt"))){ return bufferedReader.readLine(); }} |
---|
可以看到,核心的行为动作就是 return bufferedReader.readLine();
,表示读取第一行的数据并返回
那如果我们想要读取两行呢?三行?
123456 | @FunctionalInterfaceinterface FileReadInterface{ // 这里接受一个BufferedReader对象,返回一个String对象 String process(BufferedReader reader) throws IOException;} |
---|
可以看到,只有一个抽象方法process()
,它就是用来处理第一步中的核心动作(读取文件内容)
至于想读取多少内容,那就需要我们在lambda表达式中定义了
123456 | // 读取一行FileReadInterface fileReadInterface = reader -> reader.readLine();// 读取两行FileReadInterface fileReadInterface2 = reader -> reader.readLine() + reader.readLine(); |
---|
processFile()
,让其接受一个函数式接口,并调用其中的抽象方法,代码如下:123456789 | // 参数为第二步我们自己手写的函数式接口public static String processFile(FileReadInterface fileReadInterface) throws IOException { try( BufferedReader bufferedReader = new BufferedReader(new FileReader("./test.txt"))){ // 这里我们不再自己定义行为,而是交给函数式接口的抽象方法来处理,然后通过lambda表达式的传入来实现多个行为 return fileReadInterface.process(bufferedReader); } } |
---|
123456789101112131415161718192021222324252627282930313233343536373839 | public class FileReaderDemo { public static void main(String[] args) throws IOException { // 第三步: // lambda表达式1 传给 函数式接口:只读取一行 FileReadInterface fileReadInterface = reader -> reader.readLine(); // lambda表达式2 传给 函数式接口:只读取两行 FileReadInterface fileReadInterface2 = reader -> reader.readLine() + reader.readLine(); // 最后一步: 不同的函数式接口的实现,表现出不同的行为 String str1 = processFile(fileReadInterface); String str2 = processFile(fileReadInterface2); System.out.println(str1); System.out.println(str2); } // 第四步: 读取文件方法,接受函数式接口作为参数 public static String processFile(FileReadInterface fileReadInterface) throws IOException { try( BufferedReader bufferedReader = new BufferedReader(new FileReader("./test.txt"))){ // 调用函数式接口中的抽象方法来处理数据 return fileReadInterface.process(bufferedReader); } } // 第一步: public static String processFile() throws IOException { try( BufferedReader bufferedReader = new BufferedReader(new FileReader("./test.txt"))){ return bufferReader.readLine(); } }}// 第二步: 我们手写的函数式接口@FunctionalInterfaceinterface FileReadInterface{ String process(BufferedReader reader) throws IOException;} |
---|
其实你会发现,我们手写的这个函数式接口,其实就是Function<T>
去除泛型化后的接口,如下所示:
123456 | @FunctionalInterfacepublic interface Function<T, R> { // 都是接受一个参数,返回另一个参数 R apply(T t);} |
---|
下面我们列出Java中常用的一些函数式接口,你会发现自带的已经够用了,基本不会需要我们自己去写
这里的手写只是为了自己实现一遍,可以加深理解程度
我们先看一个例子
前面我们写的lambda表达式,其实还可以简化,比如
12345 | // 简化前Function<Cat, Integer> function = c->c.getAge();// 简化后Function<Cat, Integer> function2 = Cat::getAge; |
---|
其中简化后的Cat::getAge
,我们就叫做方法引用
方法引用就是引用类或对象的方法;
下面我们列出方法引用的三种情况:
像我们上面举的例子就是第三种:类的实例方法
下面我们用代码演示上面的三种方法:
12345678910111213141516171819202122232425262728293031323334 | public class ReferenceDemo { public static void main(String[] args) { // 第一种:引用对象的实例方法 Cat cat = new Cat(1); Function<Cat, Integer> methodRef1 = cat::getSum; // 第二种:引用类的静态方法 Supplier<Integer> methodRef2 = Cat::getAverageAge; // 第三种:引用类的实例方法 Function<Cat, Integer> methodRef3 = Cat::getAge; }}class Cat { int age; public Cat(int age) { this.age = age; } // 获取猫的平均年龄 public static int getAverageAge(){ return 15; } // 获取两只猫的年龄总和 public int getSum(Cat cat){ return cat.getAge() + this.getAge(); } public int getAge() { return age; } public void setAge(int age) { this.age = age; }} |
---|
为啥要用这个方法引用呢?
方法引用好比lambda表达式的语法糖,语法更加简洁,清晰
一看就知道是调用哪个类或对象的哪个方法
上面介绍了方法引用,就是直接引用某个方法
这里的构造引用同理可得,就是引用某个类的构造方法
构造引用的表达式为:Class::new
,仅此一种
如果你有多个构造函数,那编译器会自己进行推断参数(你看看,多好,多简洁)
比如下面的代码:
12345 | // 这里调用 new Cat()Supplier<Cat> constructRef1 = Cat::new;// 这里调用 new Cat(Integer)Function<Integer, Cat> constructRef2 = Cat::new; |
---|
要求引入lambda表达式中的变量,必须是最终变量,即该变量不会再被修改
比如下面的代码:
12345678 | public static void main(String[] args) { String str = "javalover.cc"; Runnable runnable = ()->{ str = "1";// 这里会报错,因为修改了str引用的指向 System.out.println(str); }} |
---|
可以看到,lambda表达式引用了外面的str引用,但是又在表达式内部做了修改,结果就报错了
为啥要有这个限制呢?
为了线程安全,因为lambda表达式有一个好处就是只在需要的时候才会执行,而不是调用后立马执行
这样就会存在多个线程同时执行的并发问题
所以Java就从根源上解决:不让变量被修改,都是只读的
那你可能好奇,我不把str的修改代码放到表达式内部可以吗?
也不行,道理是一样的,只要lambda有用到这个变量,那这个变量不管是在哪里被修改,都是不允许的
不然的话,我这边先执行了一次lambda表达式,结果你就改了变量值,那我第二次执行lambda,不就乱了吗
最后是lambda的必杀技:组合操作
在这里叫组合或者复合都可以
概述:组合操作就是先用一个lambda表达式,然后再在后面组合另一个lambda表达式,然后再在后面组合另另一个lambda表达式,然后。。。有点像是链式操作
学过JS的都知道Promise,里面的链式操作就和这里的组合操作很像
用过Lombok的朋友,应该很熟悉@Builder注解,其实就是构造者模式
下面我们用代码演示下组合操作:
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950 | // 重点代码public class ComposeDemo { public static void main(String[] args) { List<Dog> list = Arrays.asList(new Dog(1,2), new Dog(1, 1)); // 1. 先按年龄排序(默认递增) // Dog::getAge, 上面介绍的方法引用 // comparingInt, 是Comparator的一个静态方法,返回Comparator<T> Comparator<Dog> comparableAge = Comparator.comparingInt(Dog::getAge); // 2. 如果有相同的年龄,则年龄相同的再按体重排序(如果年龄已经比较出大小,则下面的体重就不会再去比较) Comparator<Dog> comparableWeight = Comparator.comparingInt(Dog::getWeight);; // 3. 调用list对象的sort方法排序,参数是Comparator<? super Dog> list.sort(comparableAge.thenComparing(comparableWeight)); System.out.println(list); }}// 非重点代码class Dog{ private int age; private int weight; public Dog(int age, int weight) { this.age = age; this.weight = weight; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public int getWeight() { return weight; } public void setWeight(int weight) { this.weight = weight; } @Override public String toString() { return "Dog{" + "age=" + age + ", weight=" + weight + '}'; }} |
---|
输出:[Dog{age=1, weight=1}, Dog{age=1, weight=2}]
比较的流程如下所示:
(a,b)->{System.out.println("javalover.cc");}
Class::new
比如list.sort(comparableAge.thenComparing(comparableWeight));