Lambda表达式（一）

什么是函数式接口

如果一个接口只有一个抽象方法（Object类中的方法除外），那么该接口就是函数式接口。@FunctionalInterface此注解是函数式接口

在jdk8中rt.jar下java.util.function包中几乎都是函数式接口

如：

1. Supplier代表输出
2. Consumer代表输入
3. BiConsumer代表两个输入
4. Function代表一个输入，一个输出
5. BiFunction代表两个输入，一个输出
6. UnaryOperator代表输入和输出相同类型

lambda表达式语法

• args ->expr
• （Object...args）->{函数式接口抽象方式实现逻辑}

1. （）里参数的个数，根据函数式接口里面抽象方法的参数个数来决定的
2. 当且仅当只有一个参数的时候，()可以省略
3. 当expr逻辑非常简单的时候，()和return可以省略

• ()->{}; //无参，无返回值
• ()->{System.out.println(1);} ; //无参，无返回值
• ()->System.out.println(1); //无参，无返回值(简写)
• ()-> {return 100;} ; //无参，有返回值，
• ()-> 100; //无参，有返回值，(简写)
• ()-> null; //无参，有返回值（返回null）
• (int x)->{ return x+1;}; //单个参数，有返回值
• (int x)-> x+1; //单个参数，有返回值(简写)
• (x) ->x+1; //单个参数，有返回值(不指定参数类型，多个参数必须用括号),lambda的特点就是参数类型自动推断，所以可以省略类型
• x ->x+1; //单个参数，有返回值(简写)

lambda的注意事项

1. (x,int y)-> x+y; //参数不能部分省略，要么(int x,int y)-> x+y ,要么(x, y)-> x+y
2. (x,final y)-> x+y; //参数不能使用final修饰
3. Object obj=()-> "hello"; //不能把lambda表达式赋值给非函数式接口，只能把lambda表达式强转成函数式接口Object obj=(Supplier)()-> "hello";
4. 不需要也不允许使用throws语句来声明它可能会抛出的异常

一些例子

package lambda1;

import java.util.concurrent.Callable;
import java.util.function.Function;
public class Test1 {
    public static void main(String[] args) throws Exception {
        // 无参无返回值
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("普通方式");
            }
        };
        r1.run();
        Runnable r2 = () -> System.out.println("lambda表达式");
        r2.run();
        // 无参有返回值
        Callable c1 = new Callable() {
            @Override
            public String call() throws Exception {
                // TODO Auto-generated method stub
                return "hello world";
            }
        };
        Callable c2 = () -> {
            return "hello lambda";
        };
        Callable c3 = () -> "hello lambda";
        System.out.println(c1.call());
        System.out.println(c2.call());
        System.out.println(c3.call());
        // 有参无返回值
        UserMapper u1 = new UserMapper() {
            @Override
            public void insert(User user) {
                // TODO Auto-generated method stub
                System.out.println("普通方式插入" + user);
            }
        };

        u1.insert(new User());
        UserMapper u2 = (User user) -> {
            System.out.println("lambda表达式插入" + user);
        };
        u2.insert(new User());
        // 有参有返回值
        OrderMapper o1 = new OrderMapper() {

            @Override
            public int del(Order order) {
                // TODO Auto-generated method stub

                return 1;
            }
        };

        OrderMapper o2 = (Order order) -> {
            return 0;
        };
        OrderMapper o3 = order -> 0;
        System.out.println(o1.del(new Order()));
        System.out.println(o2.del(new Order()));
        System.out.println(o3.del(new Order()));

        Function fun1 = a -> {
            int sum = 0;
            for (int i = 0; i < a; i++) {
                sum++;
            }
            return sum;
        };
        System.out.println(fun1.apply(9));

        Runnable ru1 = () -> get();// 无返回值当执行方法的只管get()方法的执行，不管有没有返回值
        Runnable ru2 = () -> exec();
        Foo f1 = () -> get();
        // Foo f2=()->exec();对于该抽象方法有返回值，但是exec()没有返回值
        Foo f3 = () -> 100;
        Foo f4 = () -> true ? 1 : -1;// 有返回值，没问题

        // 如何直接调用接口中的非抽象方法
        System.out.println(f1.get());
        System.out.println(Foo.find());

    }
    static void exec() {
     
    }
    static int get() {
       return 1;     
    }
}
//函数是接口中的抽象方法不能是Object类中的方法
@FunctionalInterface
interface UserMapper{
     void insert(User user);
     default void get() {
         System.out.println("这不是抽象方法");
     }
      static void find() {
         System.out.println("这也不是抽象方法");
     }
}
interface OrderMapper{
     int del(Order order);
}
interface Foo{
     int make();
     default int get() {
         return 1000;
     }
     static int find() {
         return 200;
     }
}
class User{
     
}
class Order{
     
}