Java常用的函数式接口

常用的函数式接口

常用的函数式接口

接口	抽象方法	功能
Supplier< T>接口	T get()	用来获取一个泛型参数指定类型的对 象数据
Consumer< T>接口	void accept(T t)	消费一个指定泛型的数据
Predicate接口	boolean test(T t)	有时候我们需要对某种类型的数据进行判断，从而得到一个boolean值结果。这时可以使用 java.util.function.Predicate 接口。
Function<T,R> 接口	R apply(T t)	java.util.function.Function<T,R> 接口用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件， 后者称为后置条件

Supplier< T>接口

java.util.function.Supplier 接口仅包含一个无参的方法： T get() 。用来获取一个泛型参数指定类型的对 象数据。

public class demoSupplier {
    public static String getSupplier(Supplier<String> str){
        return str.get();
    }

    public static void main(String[] args) {
        String supplier = getSupplier(() -> "你好");
        System.out.println(supplier);
    }
}

Consumer< T>接口

java.util.function.Consumer 接口则正好与Supplier接口相反，它不是生产一个数据，而是消费一个数据， 其数据类型由泛型决定。

import java.util.function.Consumer;


public class demoConsumer {
    public static void work(String str, Consumer<String> con){con.accept(str);};

    public static void main(String[] args) {
        work("大青蛙",(String str)-> System.out.println(str.length()));
    }

}

默认方法andThen
如果一个方法的参数和返回值全都是 Consumer 类型，那么就可以实现效果：消费数据的时候，首先做一个操作， 然后再做一个操作，实现组合。而这个方法就是 Consumer 接口中的default方法 andThen 。

Consumer<String> con1;
Consumer<String> con2;

String str = "大青蛙";
con1.accept(str);
con2.accept(str);

先把字符串进行连接 再消费
con1.andThen(con2).accept(str); 谁在前谁先消费

public class demoConsumer1 {

    public static void word(String str, Consumer<String> con1, Consumer con2){con1.andThen(con2).accept(str);};

    public static void main(String[] args) {
        word("大青蛙",(str)-> System.out.println(str.length()),(str)-> System.out.println(str));
    }


}

Predicat接口

有时候我们需要对某种类型的数据进行判断，从而得到一个boolean值结果。这时可以使用 java.util.function.Predicate 接口。

抽象方法：
Predicate 接口中包含一个抽象方法： boolean test(T t) 。

public class demoPredicate {

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

    public static void main(String[] args) {
        String s = "123456";
        boolean b = theString(s, (str) -> s.length() > 5);
        System.out.println(b);
    }
}

默认方法and：

既然是条件判断，就会存在与、或、非三种常见的逻辑关系。其中将两个 Predicate 条件使用“与”逻辑连接起来实 现“并且”的效果时，可以使用default方法 and 。
默认方法or：
与 and 的“与”类似，默认方法 or 实现逻辑关系中的“或”。
默认方法negate：
“与”、“或”已经了解了，剩下的“非”（取反）。
e:

public class demoPredicate1 {
    public static boolean theSin(String s , Predicate<String> s1 ,Predicate s2){
        return s1.and(s2).test(s);
    }

    public static void main(String[] args) {
        String s = "134556";
        boolean b = theSin(s, (s1 -> s.length() < 7), s2 -> s.length() > 5);
        System.out.println(b);
    }
}

Function接口

java.util.function.Function<T,R> 接口用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件， 后者称为后置条件。

抽象方法：
Function 接口中主要的抽象方法为： R apply(T t) ，根据类型T的参数获取类型R的结果。
使用的场景例如：将 String 类型转换为 Integer 类型。

public class demoFunction {
    public static Integer theFace(String s, Function<String,Integer> f){
        return f.apply(s);
    }

    public static void main(String[] args) {
        String s = "2";
        Integer integer = theFace(s, f -> Integer.parseInt(s));
        System.out.println(integer);
    }
}

默认方法：andThen:
Function 接口中有一个默认的 andThen 方法，用来进行组合操作.