lambda表达式

一、什么是lambda表达式

lambda是接口的一种实现方式，是JDK 1.8的新特性

二、怎么使用lambda表达式

2.1 接口的使用过程

第一步：定义接口

第二步：接口实现

第三步：接口使用

2.2 lambda实现接口

接口定义

public interface IMathOperation {
    int add(int x,int y);
}//接口的定义

接口的实现和使用

public class Test {
    public static void main(String[] args) {
        //接口的实现 使用lambda表达式
        IMathOperation im = (x,y)->{
            return x+y;
        };
        //接口的使用
        System.out.println(im.add(5, 6));
    }
}

2.3 lambda表达式的写法

语法：（参数）->{方法体}

情况一：只有一个参数

public interface IMathOperation {
    void add(int x);
}
class Test1{
    public static void main(String[] args) {
        IMathOperation im = (x) -> {
            System.out.println(x);
        };
        // x ->System.out.println(x);可以省略()以及{},但都不推荐
        im.add(5);
    }
}

只有一个参数时，()可以省略，不推荐省略。

方法实现只有一行代码时，可以省略{}，不推荐省略。

情况二：有多个参数

public interface IMathOperation {
    void add(int x,int y);
}
class Test1{
    public static void main(String[] args) {
        IMathOperation im = (x,y) -> {
            System.out.println(x+y);
        };
        im.add(5,9);
    }
}

情况三：没有参数

public interface IMathOperation {
    void add();
}
class Test1{
    public static void main(String[] args) {
        IMathOperation im = () -> {
            System.out.println("没有参数");
        };
        im.add();
    }
}

在方法实现中没有代码时，要写上{}空方法体

IMathOperation im = () -> { };
im.add();

2.4 lambda表达式的特征

• 可选的类型声明：不需要声明参数类型，编译器可以自动识别参数类型。
• 可选的参数圆括号：一个参数无需使用圆括号，只要不是一个参数则需要使用圆括号。
• 可选的花括号：如果函数体只有一条语句，则不需要使用花括号。

2.5 lambda的限制条件

lambda表达式在实现接口时，接口只允许有且只有一个抽象方法。

这种限制可以使用函数式接口来定义

三、函数式接口

3.1 什么是函数式接口

函数式接口（@FunctionalInterface）：

Lambda表达式相当于对接口中的方法给出了实现，如果在接口中声明了多个抽象方法，那么Lambda表达式实现的是哪个方法呢？无法确定，因此要求Lambda表达式实现的接口只能有一个抽象的方法，这样的接口称为函数式接口。

为了避免接口中出现多个抽象方法，可以在接口上使用`@FunctionalInterface`注解，声明该接口是一个函数式接口，例如：

@FunctionalInterface
public interface IMathOperation {
    void add();
}

如果在接口中声明了另外的抽象方法，那么在编译的时候，编译器就会提示错误。

@FunctionalInterface//报错了，这个接口有两个抽象方法
public interface IMathOperation {
    void add();
    void show();//添加一个抽象方法
}

Multiple non-overriding abstract methods found in interface IMathOperation

3.2 内置函数式接口

内置函数式接口：帮我们定义了接口，我们无需再自己定义接口了

既然Lambda表达式需要配合函数式接口来使用，且在函数式接口中只有一个抽象方法，那么完全可以针对方法的参数个数，以及是否有返回值，来定义一些常用的函数式接口。至于参数类型和返回值类型，则可以使用泛型来表示。

其实我们的Lambda表达式就是对函数式接口的一种简写方式，所以只有是函数式接口，我们才能用Lambda表达式；再换句话说，Lambda表达式需要函数式接口的支持，那函数式接口我们可以自己定义，当然JDK1.8也给我们提供了一些现成的函数式接口；

Java 8在java.util.function包中，定义了许多函数式接口，下表列出了四个基本的函数式接口。

例如

• Consumer< T >

class Test1{
    public static void main(String[] args) {
        Consumer<String> im = (s) -> {
            System.out.println(s);
        };
        im.accept("Consumer");
    }
}

• Predicate< T >

class Test1{
    public static void main(String[] args) {
        Predicate<String> im = (s) -> {
            if (s.equals("芝麻开门")){
                System.out.println("密码正确");
                return true;
            }else {
                return false;
            }
        };
        im.test("芝麻开门");
    }
}

• Function< T,R >

class Test1{
    public static void main(String[] args) {
        Function<Integer,String> im = (x) -> {
            return x>0?"正确":"错误";
        };
        System.out.println(im.apply(10));
    }
}

• Supplier

class Test1{
    public static void main(String[] args) {
        Supplier im = () -> {
            return "很久很久以前，巨龙突然出现";
        };
        System.out.println(im.get());
    }
}

四、方法引用

方法引用：帮我们完成了接口实现，省去了我们自己定义Lambda表达式

如果一个类中的实现方法，其参数列表和返回值类型与某个函数式接口中的方法一致，那么可以使用方法引用的方式来代替Lambda表达式。Java编译器会利用函数式接口中方法的参数来调用引用的方法，并将该方法的返回值（如果有的话）作为接口方法的返回值。
方法引用使用操作符“::”将对象或者类的名字与方法名分隔开。主要有以下三种形式：

● 对象::实例方法名
● 类名::静态方法名
● 对象::静态方法名

class Test1{
    public static String getStr1(String str1){
        return str1;
    }
    public  String getStr2(String str2){
        return str2;
    }
    public static void main(String[] args) {
        Function<String,String> fun = (str) -> {
            return "很久很久以前\n巨龙突然出现\n"+str;
        };
        System.out.println(fun.apply("带来灾难\n" +"带走了公主又消失不见"));

        //类名::静态方法名
        Function<String,String> fun1 = Test1::getStr1;
        System.out.println(fun1.apply("很久很久以前\n巨龙突然出现\n"));

        //对象::实例方法名
        Test1 test = new Test1();
        Function<String,String> fun2 = test::getStr2;
        System.out.println(fun2.apply("带来灾难\n" + "带走了公主又消失不见"));
    }
}