java 优雅的使用lambda表达式和闭包
java 1.8 加入了lambda的语法，使用lambda语法糖可以让我们的代码更简洁优雅，写起来更爽。
下面看个例子感受一下 :
public class Lambda {
@Getter
@Setter
@AllArgsConstructor
static class Student{
String name;
Integer age;
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public static void main(String[] args) {
List<Student> list = Arrays.asList(
new Student("a",10)
,new Student("b",30)
,new Student("c",15)
,new Student("d",20));
list.sort((x,y)->x.getAge()-y.getAge());
list.forEach(System.out::println);
}
上面的代码实现了student对象集合的排序和循环输出，是不是相比普通的写法简洁了许多。
lambda代替了什么
我们知道lambda是一种语法糖，那么我们简写了什么呢？
list.sort((x,y)->x.getAge()-y.getAge());//排序
比如上面这行代码，sort的参数是一个Comparator类型的对象
default void sort(Comparator<? super E> c)
Comparator是一个接口，其中只有一个方法需要被实现，就是compare方法。所以实际上我们是写了一个内部类
int compare(T o1, T o2);
内部类
那么如果是没有lambda之前是什么样呢，我们看一下:
list.sort((x,y)->x.getAge()-y.getAge());
list.sort(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return o1.getAge()-o2.getAge();
}
});
可以看出lambda的强大了吧，写起来就是爽。
在jdk中一般可以用lambda简写的接口都会有@FunctionalInterface注解。
语法和技巧
一个标准的lambda由下面的结构构成
(参数,参数)->{
方法体
}
简化结构
- 参数支持类型推导，所以我们不必写参数的类型
- 当大于等于两个参数时要用括号包起来，一个参数则不用
- 如果方法体内只有一行代码，可以省略花括号。并且如果有返回值，那么会将这一行代码的结果作为返回值
@FunctionalInterface
interface fun<T>{
int f(T t);
}
fun<student> fun = s ->s.getAge();
静态方法调用
在调用静态方法时可以使用 类名::方法名 双冒号的语法，但要求静态方法的参数列表和lambda的参数列表一致
比如上面的sort，我们定义一个静态方法,然后就可以这样用了
static int staticM(Student Student){
return student.getAge();
}
static int staticM2(Student o1,Student o2){
return o1.getAge()-o2.getAge();
}
fun<Student> fun = Lambda::staticM; //表示 调用Lambda类的静态方法staticM = integers.forEach(s->System.out.println(s));
list.sort(Lambda::staticM2); //表示 调用Lambda类的静态方法staticM2 = integers.sort((o1,o2)->Lambda.staticM2(o1,o2));
前面的integers.forEach(System.out::println);也是一样的用法。
调用参数对象的方法
@FunctionalInterface
interface fun<T>{
int f(T t);
}
//使用
fun<Student> fun = Student::getAge;// = fun<Student> fun = s->s.getAge();
当lambda表达式参数为一个时， 可以使用 类名::无参方法 的方式。
注意，这个方式只能调用无参方法，所以能用来调用get不能用来调set
闭包
闭包的概念
函数可以访问函数外部的变量，并且与它建立联系，可以修改变量和读取到外部对变量的修改
首先lambda表达式可以使用表达式外的变量，但要求使用的变量是final的，（逻辑上要求，并不强制要求final修饰）
@FunctionalInterface
interface fun {
void f();
}
@Setter
@Getter
@AllArgsConstructor
static class MyInter{
Integer i;
}
public static void main(String[] args) {
Integer a = 1;
fun fun = ()->System.out.println(a);
//a=2;
}
我们使用了变量a，这是没问题的。
但是如果我们再加一行 a =2； 那么就会编译报错,如果我们在lambda里面修改了a也是不行的。
java编译时已经强制要求lambda使用的变量不可修改了，所以final关键字不是必须的。
不能修改那么就达不成闭包的条件。
哪有什么办法可以修改呢
答案是用一个对象包起来
@FunctionalInterface
interface fun {
void f();
}
@Setter
@Getter
@AllArgsConstructor
static class MyInter{
Integer i;
}
public static void main(String[] args) {
MyInter inter = new MyInter(1);
fun fun = ()->inter.setI(2);
fun.f();
System.out.println("lambda修改后："+inter.getI());
inter.setI(3);
System.out.println("直接修改后："+inter.getI());
}
我们用一个MyInter对象把变量a封装起来。不修改MyInter对象，而修改它的属性，这样就可以实现了。
输出为
lambda修改后：2
直接修改修改后：3
这就达成了闭包的条件.
闭包的价值
举个栗子：打印给定数量的 斐波那契数列
用闭包实现的例子：
@FunctionalInterface
interface fun {
int f();
}
@Setter
@Getter
@AllArgsConstructor
static class MyInter {
Integer i;
}
public static void main(String[] args) {
print(10);
}
public static void print(int n) {
MyInter last = new MyInter(0);
MyInter next = new MyInter(1);
fun fun = () -> {
int r = next.getI();
int i = last.getI() + next.getI();
last.setI(next.getI());
next.setI(i);
return r;
};
for (int i = 0; i < n; i++) {
System.out.println(fun.f());
}
}
使用闭包就是这么简单。当然实际写的还是挺多的也不咋优雅，使用调方法的方式也可以实现。如果是其它语言会更简洁。
比如go：
func main() {
n:=10
last, next := 0, 1
f := func() int {
last, next = next, (last + next)
return last
}
for i := 0; i < n; i++ {
fmt.Println(f())
}
}
差距好大，希望java能多学习学习其它语言的优势。
