Java8新特性之Lambda 表达式

public class LambdaDemo {
    public static void main(String[] args) {
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("args = " + args);
            }
        };
        r1.run();

        Runnable r2 = ()-> System.out.println("LambdaDemo.main");
        r2.run();
    }
}

如上：

r1 是 匿名内部类

r2用的是Lambda表达式

1、本质就是把“一块代码”赋给了一个变量，这块代码，实现了这个接口的抽象方法。

2、lambd表达式只适应于只有一个抽象方法的接口

Runnable r2 =

r2的类型，Runnable必须是一个接口，且这个接口下只能有一个抽象的方法

3、使用 -> 分左右

左侧是，接口抽象方法的参数列表。当参数只有一个时,()可以省略

参数1 -> 表达式 

或者

（参数1）->表达式

右侧是，实现抽象方法的方法体

4、方法体只有一行的时候，{} 可以省略，如上r2=

给一个list的元素排序，按照元素长度大小来排

List list = Lists.newArrayList("1234","456","abefc");

正常的流程，我们需要新建一个比较器，实现Comparator 这个接口

import java.util.Comparator;

public class MyCompareList implements Comparator {

    @Override
    public int compare(String o1, String o2) {
        return o1.length()-o2.length();
    }
}

然后在Collections.sort 中传入这个比较器

List list = Lists.newArrayList("1234","456","abefc");

Collections.sort(list,new MyCompareList());
System.out.println(list);

Lambda表达式-------------

        List list = Lists.newArrayList("1234","456","abefc");
        Collections.sort(list,(o1,o2)->o1.length()-o2.length());
        System.out.println(list);

1、sort(list，）这里肯定是传一个实现接口Comparator的类

2、(o1,o2)->o1.length()-o2.length() 实现了Comparator的compare方法

3、compare方法，是需要return的。这里注意：

lambda表达式，如果return代码只有一行的时候，return可以省略。

4、（o1,o2)这个是compare方法的参数列表。

5、我们通过匿名内部类实现比较器

        List list = Lists.newArrayList("1234","456","abefc");
        Collections.sort(list, new Comparator() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length()-o2.length();
            }
        });

在实现Comparator这个接口的时候，我们都需要指定参数类型的。

但是我们在lambda表达式里，并没有指定参数类型

        Collections.sort(list,(o1,o2)->o1.length()-o2.length());

这是因为

Java 8 lambda 会进行类型推断

参数列表中，凡是可以推断出来的类型，参数的类型可以省略。

通常情况下，都是可以推断出来的，可以省略参数类型，除了一些很复杂的情况。

在这里，我们指定类型，也不会报错

        Collections.sort(list,(String o1,String o2)->o1.length()-o2.length());

public class LambdaDemo1 {
    public static void main(String[] args) {
        Coo c = x -> x+1;

    }
}
interface Coo{
    int coo(int x);
}

如上，自定义了一个接口Coo，和抽象方法coo。 实现了lambda表达式。

注意：

实现lambda表达式的前提是，这个接口下，只有一个抽象方法

当其他开发人员，在我们自定义类下，新增了其他抽象方法时。

我们lambda表达式，就报错了.

为了避免这种情况，Java8提供了一个注解@FunctionalInterface

在我们自定义接口，加上这个注解后，其他人再在这个接口上添加抽象方法时，就会报错。

------------------------------

public class LambdaDemo1 {
    public static void main(String[] args) {
        Coo c = x -> x+1;

    }
}
@FunctionalInterface
interface Coo{
    int coo(int x);
}