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能多学习学习其它语言的优势。