Java学习笔记——函数式接口

一、函数式接口概述

函数式接口：有且仅有一个抽象方法的接口。
Java中的函数式编程体现就是Lambda表达式，所以函数式接口就是可以适用于
Lambda表达式使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的
Lambda表达式才能顺利地进行推导。

可以在接口定义的上方加上一个注解@FunctionalInterface来表示该接口是一个
函数式接口。如下所示：

@FunctionalInterface
public interface MyInterface {
    void show();
}

二、常用的四种函数式接口

1、Supplier接口
Supplier接口包含了一个无参的方法：
（1）T get()：获得结果，该方法不需要参数，它会根据某种逻辑返回一个数据。
 
 Supplier接口也被称作生产性接口，get方法返回的数据类型和泛型中指
 定的数据类型一致。
例如：

public static void main(String[] args) {

        //Lambda表达式
        String s1 = getString(() -> "asdf");
        System.out.println(s1);

        //Lambda表达式
        int i = getInteger(() -> 2);
        System.out.println(i);

    }

    //定义一个方法返回整数
    private static Integer getInteger(Supplier<Integer> s) {
        return s.get();
    }

    //定义一个方法返回字符串数据
    private static String getString(Supplier<String> s) {
        return s.get();
    }

2、Consumer接口
Consumer接口包含两个方法：
(1)void accept(T t)：对给定的参数进行操作
(2)default Consumer andThen(Consumer after):返回一个组合Consumer
依次执行此操作然后执行after操作。

Consumer接口也被称作消费接口，消费的数据类型由泛型决定。

public static void main(String[] args) {

    operatorString("杨玉环", s -> System.out.println(new StringBuilder(s).reverse()));
    System.out.println("-----------");

    operatorString("王昭君", s -> System.out.println(new StringBuilder(s).reverse()), s -> System.out.println(s));


}
    //定义一个方法消费字符串，用不同的方式消费同一个字符串两次
    private static void operatorString(String s, Consumer<String> c1, Consumer<String> c2) {
//        c1.accept(s);
//        c2.accept(s);
        c1.andThen(c2).accept(s);
    }


    //定义一个方法消费字符串
    private static void operatorString(String s, Consumer<String> c) {
        c.accept(s);
    }

运行结果：
		环玉杨
		-----------
		君昭王
		王昭君

---

3、Predicate接口
Predicate接口常用的有四个方法：
(1) boolean test(T t) 对给定参数进行判断，返回一个布尔值
(2) default Predicate negate() 返回一个逻辑的否定，对应逻辑非
(3) default Predicate  and(Predicate other) 返回一个组合判断，对
应短路与。
(4) default Predicate or(Predicate other) 返回一个组合判断，对
应短路或。

public static void main(String[] args) {

        boolean b = checkString("aa", s1 -> s1.equals("aa"));
        System.out.println(b);

        boolean b1 = checkString("hello", s1 -> s1.length() > 3);
        System.out.println(b1);

        System.out.println("=============");
        boolean b2 = checkString("helloworld", s1 -> s1.equals("aa"), s2 -> s2.length() > 12);
        System.out.println(b2);


    }

    //判断给定的字符串是否满足要求
    private static boolean checkString(String s, Predicate<String> p) {
//        return p.test(s);
        return p.negate().test(s);
    }

    //同一个字符串给出两个不同的判断，最后把这两个判断的结果做逻辑与运算的结果作为最终结果
    private static boolean checkString(String s, Predicate<String> p1, Predicate<String> p2) {
//        boolean b1 = p1.test(s);
//        boolean b2 = p2.test(s);
//
//        return b1 && b2;
//        return p1.and(p2).test(s);
        return p1.or(p2).test(s);
    }

4、Function接口
Function接口有两个常用方法：
(1) R apply(Function) 将此函数应用于给定的参数
(2)default  Function	andThen​(Function after)	
返回首先将此函数应用于其输入的 after函数，然后将 after函数应用于结果。

Function接口常用于对参数进行操作转换，然后返回一个新的值。

public static void main(String[] args) {
        convert("1000", s -> Integer.parseInt(s));

        convert(100, s1 -> String.valueOf(s1));

        convert("200", s -> Integer.parseInt(s), s2->String.valueOf(s2+100));
    }

    //定义一个方法把字符串类型转换成int类型并输出
    private static void convert(String s, Function<String, Integer> f) {
        Integer i = f.apply(s);
        System.out.println(i);
    }

    //定义一个方法，把一个int类型的数加上一个整数后转换成字符串后输出
    private static void convert(Integer i, Function<Integer, String> f) {
        int result = i + 100;
        String s = f.apply(result);

        System.out.println(s);
    }

    //定义一个方法把一个字符串转换成int类型，把int加上一个整数后，转换成字符串
    private static void convert(String s, Function<String, Integer> f1, Function<Integer, String> f2) {
        String apply = f1.andThen(f2).apply(s);
        System.out.println(apply);
    }