lambda表达式及四大函数式接口

1. lambda表达式简介

lambda表达式是java8开始的新特性，可以看作匿名函数

功能则是将一个函数作为另一个函数的参数

2. lambda表达式的三种编写方式

(1) expression 单条语句执行(不用加{ })

函数式接口使用

简单示例

复杂示例

当参数只有一个的时候，可以省略空格

使用单语句时可以省略return

(2) statement 语句块(使用{ }包裹函数)

使用示例

示例2

(3) refernce 方法引用

简单示例

示例2

3. 函数式接口

@FunctionalInterface注解

@FunctionalInterface注解的功能就是约束一个接口只能有一个方法，参数没有限制，返回值可有可无

当一个接口使用该注解，就代表该接口是一个函数式接口，也就可以使用lambda表达式简化使用

四大函数式接口

jdk1.8拥有的新功能

• ① Function<T, R> : 函数型接口

•   R apply(T t);
  

• ② Consumer : 消费型接口

•   void accept(T t);
  

• ③ Supplier : 供给型接口

•   T get();
  

• ④ Predicate : 判断型接口

•  boolean test(T t);
  

(1) Function(函数型接口)

有参数、有返回值

使用示例

public static void main(String[] args) {
        //1. 普通方式
        Function<String,String> function1 = new Function<String, String>() {
            @Override
            public String apply(String s) {
                return "hello，"+s;
            }
        };

        //2.lambda表达式方式
        Function<String,String> function2 = (str) -> {return "hello,"+str;};

        //3. 再简化
        Function<String,String> function3 = str -> "hello,"+str;

        //使用
        System.out.println(function1.apply("小明"));
        System.out.println(function2.apply("小红"));
        System.out.println(function3.apply("单身汪"));
    }

(2) Predicate (判断型接口)

有参数，返回一个boolean值

使用示例

 public static void main(String[] args) {
        //1.普通方式
        Predicate<String> predicate1 = new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.equals("小明");
            }
        };

        //2.lambda方式
        Predicate<String> predicate2 = (s) -> {return s.equals("小明");};

        //3.再简化
        Predicate<String> predicate3 = s -> s.equals("小明");

        System.out.println(predicate1.test("小明")); //true
        System.out.println(predicate2.test("小红")); //false
        System.out.println(predicate3.test("小丑")); //false
    }

(3) Consumer (消费型接口)

有参数，无返回值

使用示例

public static void main(String[] args) {

        //1.普通方式
        Consumer consumer1 = new Consumer() {
            @Override
            public void accept(Object name) {
                System.out.println((String)name+"正在消费");
            }
        };

        //2.lambda表达式方式
        Consumer consumer2 = (name)->{
            System.out.println((String)name+"正在消费");
        };

        //3.简化
        Consumer consumer3 = name->  System.out.println((String)name+"正在消费");

        //4.再简化 右侧相当于是将一个方法作为函数式接口的实现
        Consumer<String> consumer4 = System.out::println;

        consumer1.accept("小明");
        consumer2.accept("小红");
        consumer3.accept("小丑");
        consumer4.accept("打工人正在消费");
    }

(4) Supplier (供给者接口)

无参数，有返回值

使用示例

public class TestSupplier {
    public static void main(String[] args) {
        //1.普通方式
        Supplier supplier1 = new Supplier() {
            @Override
            public Object get() {
                return new Hambuger("小明");
            }
        };

        //2.lambda表达式方式
        Supplier supplier2 = ()->{return new Hambuger("小红");};

        //3.简化
        Supplier supplier3 = ()-> new Hambuger("小丑");

        Object hambuger1 = supplier1.get();
        Object hambuger2 = supplier2.get();
        Object hambuger3 = supplier3.get();

        System.out.println(hambuger1);
        System.out.println(hambuger2);
        System.out.println(hambuger3);
    }
}
//汉堡类
class Hambuger{
    String name;
    Hambuger(String name){
       this.name = name+"做的汉堡";
    }
    @Override
    public String toString() {
        return name;
    }
}