一、函数式接口概述

函数式接口：有且仅有一个抽象方法的接口。
Java中的函数式编程体现就是Lambda表达式，所以函数式接口就是可以适用于
Lambda表达式使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的
Lambda表达式才能顺利地进行推导。可以在接口定义的上方加上一个注解@FunctionalInterface来表示该接口是一个
函数式接口。如下所示：

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

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

1、Supplier接口
Supplier<T>接口包含了一个无参的方法：
（1）T get()：获得结果，该方法不需要参数，它会根据某种逻辑返回一个数据。Supplier<T>接口也被称作生产性接口，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<T>接口包含两个方法：
(1)void accept(T t)：对给定的参数进行操作
(2)default Consumer<T> andThen(Consumer after):返回一个组合Consumer
依次执行此操作然后执行after操作。Consumer<T>接口也被称作消费接口，消费的数据类型由泛型决定。

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<T>接口常用的有四个方法：
(1) boolean test(T t) 对给定参数进行判断，返回一个布尔值
(2) default Predicate<T> negate() 返回一个逻辑的否定，对应逻辑非
(3) default Predicate<T>  and(Predicate other) 返回一个组合判断，对
应短路与。
(4) default Predicate<T> 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<T,R>接口有两个常用方法：
(1) R apply(Function<T,R>) 将此函数应用于给定的参数
(2)default <V> Function<T,​V>	andThen​(Function<? super R,​? extends V> after)	
返回首先将此函数应用于其输入的 after函数，然后将 after函数应用于结果。Function<T,R>接口常用于对参数进行操作转换，然后返回一个新的值。

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);}