Java8 函数式接口

文章目录

• ​​一、特点​​
• ​​二、函数式接口中允许定义的方法类型​​
• ​​三、四大内置函数式接口​​

• ​​1. `Consumer` 消费​​

• ​​1.1 示例​​

• ​​2. `Supplier` 供应​​

• ​​2.1示例​​

• ​​3. `Function`方法​​

• ​​3.1 示例​​

• ​​4.`Predicate` 谓词​​

• ​​4.1 示例​​

一、特点

• 是一个接口，有接口的所有特点
• 函数式接口中只能有一个抽象方法

二、函数式接口中允许定义的方法类型

• 默认方法（已经有默认实现）
• 静态方法 （已经实现）
• Object类的public方法（继承自父类已经有父类的实现

起来就是这几种方法都已经有了实现，以保证Lambda表达式中调用的为实现的方法就是函数式接口中定义的抽象方法，而非别的方法，都是为了Lambda实现行为参数化考虑，如果有多个未实现的抽象方法就会出现多个指向，从而出现错误。

三、四大内置函数式接口

Lambda 表达式的使用前提是函数式接口，为了便利 Lambda 表达式的使用，Java8 提供了内置的四大函数式接口，四大函数式接口满足了程序设计的大部分情况，省去了使用 Lambda 表达式时写函数式接口的步骤。四大函数式接口分别为：Consumer、Supplier、Function、Predicate。

1. ​​Consumer​​ 消费

​​Consumer​​是一个消费者，用于消费T类型的对象，没有返回值。

• ​​accept()​​: 没有返回值类型，用于处理T类型的对象
• ​​andThen()​​: 指定调用完当前 Consumer 方法后是否还需要调用其它 Consumer 的 accept() 方法的 default 方法

1.1 示例

package demo;

import entity.Student;

import java.util.function.Consumer;

/**
 * consumer demo
 *
 * @author dingwen
 * 2021.05.19 10:47
 */
public class ConsumerDemo {
    public static void main(String[] args) {
        Consumer<Student> consumer1 = (student -> print(student.getName()));
        Consumer<Student> consumer2 = (student -> print(student.getGender()));

        Student student = new Student();
        student.setGender("男");
        student.setName("dingwen");

//        consumer2.accept(student);
        consumer1.andThen(consumer2).accept(student);
    }


    /**
     * 打印
     *
     * @param str str
     */
    public static void print(String str) {
        System.out.println(str);
    }
}

2. ​​Supplier​​ 供应

Supplier是一个供应商，不需要提供任何参数，就可以获得提供一个T类型的对象。

• ​​get()​​: 仅有一个提供T类型对象的抽象方法

2.1示例

package demo;

import java.util.function.Supplier;

/**
 * supplier demo
 *
 * @author dingwen
 * 2021.05.19 11:09
 */
public class SupplierDemo {

    public static void main(String[] args) {
        Supplier<SupplierDemo> supplier = SupplierDemo::new;
        supplier.get().supplierTest();
    }

    /**
     * supplier测试
     */
    public void supplierTest(){
        System.out.println("supplier test");
    }
}

3. ​​Function​​方法

Function是一个函数，经常被作为做为一个中间函数调用。

• ​​apply()​​: 用于处理T类型的数据，返回R类型的结果
• ​​andThen()​​: 指定当前的 Function 的 apply() 方法执行完毕后是否需要执行的下一个 Function，先执行调用者
• ​​compose()​​: 指定当前的 Function 的 apply() 方法执行完毕后是否需要执行的下一个 Function，先执行参数
• ​​identify()​​：返回当前正在执行的方法的一个静态方法

3.1 示例

package demo;

import java.util.function.Function;

/**
 * function demo
 *
 * @author dingwen
 * 2021.05.19 11:30
 */
public class FunctionDemo {
    public static void main(String[] args) {
        Function<Integer, Integer> function1 = number -> number * 2;
        Function<Integer, Integer> function2 = FunctionDemo::test;

        Integer value1 = function1.apply(2);
        System.out.println(value1);// 4

        Integer value2 = function2.apply(3);
        System.out.println(value2);// 9

        Integer value3 = function1.andThen(function2).apply(3);
        System.out.println(value3); // 36

        // 先处理参数
        Integer value4 = function1.compose(function2).apply(3);
        System.out.println(value4); // 18

        //返回一个执行了apply()方法之后只会返回输入参数的函数对象
        Object identity = Function.identity().apply("hello");
        System.out.println(identity);


    }

    public static Integer test(Integer number) {
        return number * number;
    }


}

4.​​Predicate​​ 谓词

处理boolean。

• ​​test()​​: 用于处理T类型的对象，返回布尔值表达式的结果
• ​​and()​​: 两个Predicate 操作 &&
• ​​or()​​: 两个Predicate 操作 ||
• ​​negate​​ : 操作结果取反 ！
• ​​isEqual()​​​:静态方法 ​​isEqual()​​，接收一个 Object 类型的对象，返回一个 Predicate 类型对象，用于判断第一个 test 的方法与第二个 test 方法是否相同

4.1 示例

package demo;

import java.sql.SQLOutput;
import java.util.function.Predicate;

/**
 * predicate demo
 *
 * @author dingwen
 * 2021.05.19 11:47
 */
public class PredicateDemo {

    public static void main(String[] args) {
        Predicate<String> predicate1 = str -> str.equals("talk");
        Predicate<String> predicate2 = str -> str.equals("test");

        String tip = "talk";
        System.out.println(predicate1.test(tip)); //true
        System.out.println(predicate1.negate().test(tip)); // !true
        System.out.println(predicate1.and(predicate2).test(tip));// true && false
        System.out.println(predicate1.or(predicate2).test(tip)); // true || false

    }
}