lamda表达式与函数式接口

lamda表达式

lamda表达式，也叫做闭包，lamda表达式允许把函数做为一个方法的参数
语法：

(parameters) -> expression
或
(parameters) ->{ statements; }

• 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
• 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号,没有参数也必须定义。
• 可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
• 可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定表达式返回了一个数值。
• 当参数、statements只有一个时，可以省略括号
• 当函数需要返回值，而statements只有一句时，可以省略return关键字。
  表达式实例如下：

//最简单的，什么都不干的函数
()->{};
//可以省略括号
x -> x++;
x -> x++
//可以省略return,
x->{ return x++;} equals  x-> x++;
//不可省略,当statements不只含有1句时，不可省略
x->{x++; return x++}
//无参与多参写法
（）-> x++;
 x-> x++;
(x,y)->x+y;

上面介绍了lamda表达式的结构和写法，那么我们如何把lamda表达式当作参数传递给方法呢，接着看

	public void test(){
    Inter1 m=(a,b)->a+b; //定义一个变量接收lamda表达式
   	invokeLamda(1,1,m);
    }
    interface Inter1 {
        int operation(int a, int b);
    }
    public void invokeLamda(a,b,Inter1 inter){ 
    	inter.operation(a,b);
    }
//输出：5

//Java1.8之前，需要灵活的执行不同的方法，只能采取匿名内部类的方式
public void test(){
    son  m=new Son();
    System.out.println(m.operation(3,2));
    }
    interface Inter1 {
        int operation(int a, int b);
    }
    class  son implements Inter1{
    @Override
        public int operation(int a,int b){
            return a+b;
        }
    }

可以看到，lamda表示式，为我们节约了不少的代码量

什么是函数式接口

指的是有且只有一个未实现的方法的接口，一般通过FunctionalInterface这个注解来表明某个接口是一个函数式接口，当然，不用注解标注也是可以的，不过一般还是推荐加上， 假如接口中存在多个抽象函数时，编译器会报错提醒，函数式接口是Java支持函数式编程的基础

Consumer c = (o) -> {
    System.out.println(o);
};

• 输入：->前面的部分，即被()包围的部分。此处只有一个输入参数，实际上输入是可以有多个的，如两个参数时写法：(a, b);当然也可以没有输入，此时直接就可以是()。
• 函数体：->后面的部分，即被{}包围的部分；可以是一段代码。
• 输出：函数式编程可以没有返回值，也可以有返回值。如果有返回值时，需要代码段的最后一句通过return的方式返回对应的值。
  当函数体中只有一个语句时，可以去掉{}进一步简化

Consumer c = (o) -> System.out.println(o);

如果是调用静态方法，可以省略入参

Consumer c = System.out::println;

函数式接口种类

在1.8之前我们就经常使用的Runnable等函数接口，JDK1.8新增了更多函数式接口，如rt.jar包下的java.util.function包里面包含的类，consumer、supplier等，下面简单介绍一下

Consumer

Consumer类预定义了一个抽象方法，接收一个参数，并无返回值，使用方式如下

Consumer c=System.out::println
//控制参数类型
Consumer<String> d=System.out::println;
//双参数函数接口
BiConsumer<Integer,Integer> c=(x,y)->System.out.print(x+y);
//实际经常使用的方式
    public void test(){
        invokeLamda(System.out::println);
    }
    public void invokeLamda(Consumer c){
        int a=3;
        c.accept(a);
    }
    //output:3

Consumer接口还提供了一个andthen（）具有函数体的默认方法（jdk1.8出现），在执行完accept函数后，再执行andthen 的函数，做一些额外的操作，源码如下

    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }

使用如下

    public void test(){
         invokeLamda(System.out::println,System.out::println);
    }
    public void invokeLamda(Consumer c,Consumer d){
        int a=3;
        c.andThen(d).accept(a);
    }
    //output:3 
    //		 3

所以使用使用函数接口还是比较简单的，只需要大概了解一下种类，再选择相应的类传入就好了，如果预定义的种类不符合业务需求，可以自己定义函数式接口，加上@FunctionalInterface，需要注意的是，这个注解不是必要的，加了后，编译器只是会检查定义的接口是否符合规范

Function

接收一个参数，并提供返回值，使用如下：

    public void test(){
        invokeLamda(x->x*x);
    }
        public void invokeLamda(Function<Integer,Integer> c){
        int a=3;
        a=c.apply(a);
        System.out.print(a);
    }

如果我们的入参需要在咱们传的函数执行前，先处理一下，比如3+3 参数变为6，写法如下

    public void test(){
        invokeLamda(x->x*x,x->x+x);
    }
        public void invokeLamda(Function<Integer,Integer> c,Function<Integer,Integer> d){
        int a=3;
        a=c.compose(d).apply(a);
        System.out.print(a);
    }
    //输出   36

可以看到，先是执行compose，后是执行了apply，前后依次调用了，同样Function里也有andThen方法，写法一样

a=c.andThen(d).apply(a);

但执行顺序是在apply执行后完成

supplier

无参，并返回一个参数

   public void test(){
        invokeLamda(()->3);
    }
        public void invokeLamda(Supplier<Integer> c){
        int a= c.get();
        System.out.print(a);
    }

Predicate

接收一个参数，返回boolean，使用如下

   public void test(){
        invokeLamda((a)->a>5);
    }
   public void invokeLamda(Predicate<Integer> c){
        int a=5;
        boolean returnflag= c.test(a);
        System.out.print(returnflag);
    }

每一个predicate相当于一个表达式，多个表达式的链接，使用如下

    public void test(){
        invokeLamda((a)->a>5,(a)->false,(a)->true);
    }
    public void invokeLamda(Predicate<Integer> b,Predicate<Integer> ...c){
        int a=5;
        for(Predicate<Integer> temp:c){
           b=b.or(temp);
        }
        boolean returnflag=b.test(a);
        System.out.print(returnflag);
    }
    //true

上面的判断，在1.8以前的写法中为

returnflag= a>5||false||true;

Predicate不仅可以或运算，也可以执行与，非，等于，几种条件的逻辑运算，不一一说明了

其他种类

DoubleBinaryOperator
代表了作用于两个double值操作符的操作，并且返回了一个double值的结果。

DoubleConsumer
代表一个接受double值参数的操作，并且不返回结果。

DoubleFunction<R>
代表接受一个double值参数的方法，并且返回结果

DoublePredicate
代表一个拥有double值参数的boolean值方法

DoubleSupplier
代表一个double值结构的提供方

这里不过多赘述了，网上有详细的结构说明，也可以自行查看java.util.function包下查看源码