JAVA-JDK中常用的函数式接口

JDK中提供了大量的函数式接口以丰富Lambda的典型使用场景，主要在java.util.function包。

<1>Supplier接口

Supplier<T> 接口仅包含一个无参的方法，T get(),用来获取一个泛型参数指定类型的对象数据 //该接口被称之为生产型接口，指定接口的泛型是什么类型，那么接口中的get方法就会生产什么类型的数据

package Demo38;
import java.util.function.Supplier;

public class Demo02Supplier {
  
    public  static String getString(Supplier<String> sup){
        return sup.get();
    }

    public static void main(String[] args) {
        String s = getString(()->{
            return "aaa";
        });
        System.out.println(s);
        //简化的lambda
        String s2 = getString(()->"aaa");
        System.out.println(s2);
    }
}

<2>Consumer<T> 接口与Supplier<T>接口相反，是消费一个数据

package Demo38;
import java.util.function.Consumer;

public class Demo03Consumer {
    public static void method(String name, Consumer<String> con){
        con.accept(name);
    }

    //该接口特有的默认方法andThen ，把两个Consumer接口组合到一起，再对数据消费
    public static void method01(String s,Consumer<String> con1,Consumer<String> con2){
//        con1.accept(s);
//        con2.accept(s);
        con1.andThen(con2).accept(s); //先con1执行消费数据后con2，等价于上面两行代码
    }

    public static void main(String[] args) {
        method("南风",(String name)->{
            System.out.println(name);
        });

        method01("hello",
                (t)->{
                    System.out.println(t.toUpperCase()); //消费数据方式是将字符串转换大写
                },
                (t)->{
                    System.out.println(t.toLowerCase());//消费数据方式是将字符串转换小写
                });
    }

}

<3>Predicate<T>接口,对某种数据类型的数据进行判断，返回一个boolean值

and,or,方法用于连接两个判断条件,negate取反

package Demo39;
import java.util.function.Predicate;

public class Demo01Predicate {

    public static boolean chechString(String s, Predicate<String> pre){
        return pre.test(s);
    }

    //and方法
    public static boolean checkString01(String s,Predicate<String> pre1,Predicate<String> pre2){
        return pre1.and(pre2).test(s);// 等价于return pre1.test(s) && pre2.test(s);
    }

    //negate方法
    public static boolean checkString02(String s,Predicate<String> pre){
        return pre.negate().test(s); //等价于 !pre.test(s)
    }

    //or方法
    public static boolean checkString(String s,Predicate<String> pre1,Predicate<String> pre2){
        return pre1.or(pre2).test(s); //等价于 return pre1.test(s) || pre2.test(s);
    }

    public static void main(String[] args) {
        String s = "code";
//        boolean b = chechString(s,(String str)->{
//            return str.length() > 5;
//        });

        boolean b = chechString(s,str -> str.length() > 5);
        System.out.println(b);

        boolean b1 = checkString01(s,(String str)->{
            return str.length()>5;
        },(String str)->{
            return str.contains("d");
        });
        System.out.println(b1);
    }
}

<4>Function<T,R>接口，接口根据一个类型的数据得到另一个数据类型的数据，前者为前置条件，后者为后置条件

该接口最主要的抽象方法是 apply(T t)

其中的默认方法andThen()用来组合操作

package Demo39;
import java.util.function.Function;

public class Demo02Function{
    public static void change(String s, Function<String,Integer> fun){
        Integer in = fun.apply(s);
        System.out.println(in);
    }

    public static void change01(String s,Function<String,Integer> fun1,Function<Integer,String> fun2){
        String ss = fun1.andThen(fun2).apply(s);
        System.out.println(ss);
    }

    public static void main(String[] args) {
        String s = "123456";
        change(s,(String str)->{
            return Integer.parseInt(str);
        });

        //将字符串转换为整形，再+10，再转换为字符串输出
        change01(s,(String str)->{
            return Integer.parseInt(str)+10;
        },(Integer i)->{
            return i+"";
        });
    }
}