Lambda表达式(一)

什么是函数式接口

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

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

如:

  1. Supplier代表输出
  2. Consumer代表输入
  3. BiConsumer代表两个输入
  4. Function<T,R>代表一个输入,一个输出
  5. BiFunction<T,U,R>代表两个输入,一个输出
  6. UnaryOperator<T>代表输入和输出相同类型

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<String> c1 = new Callable<String>() {
            @Override
            public String call() throws Exception {
                // TODO Auto-generated method stub
                return "hello world";
            }
        };
        Callable<String> c2 = () -> {
            return "hello lambda";
        };
        Callable<String> 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<Integer, Integer> 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{
     
}

推荐阅读更多精彩内容