Java8 函数式接口

Posted 2021-05-20 dingwen_blog

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java8 函数式接口相关的知识，希望对你有一定的参考价值。

文章目录

一、特点

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

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

默认方法（已经有默认实现）
静态方法（已经实现）
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

    }
}