大部分函數式接口都不用我們自己寫，Java8都給我們寫好啦。這些接口都在java.util.function包里，下面簡單介紹其中的幾個。
（1）Predicate函數式接口
Predicate是一個斷言型接口，用于做判斷操作，所以抽象方法返回的是Boolean。該接口包含多種默認方法來將Predicate組合成其他復雜的邏輯（與、或、非）。
Predicate接口定義如下：
@FunctionalInterface
public interface Predicate<T> {
boolean test(T t);
//返回值為已實現Predicate接口抽象方法的類
default Predicate<T> and(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) && other.test(t);
}
default Predicate<T> negate() {
return (t) -> !test(t);
}
default Predicate<T> or(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) || other.test(t);
}
static <T> Predicate<T> isEqual(Object targetRef) {
return (null == targetRef)
? Objects::isNull
: object -> targetRef.equals(object);
}
1. Predicate的基本使用
public class Main{
@Test
public void test(){
List<String> list = Arrays.asList("hEOOL","AJS","ashdkjas","ww");
List<String> strlist = filterStr(list,(s)->s.length()>3);
}
// 需求：將滿足條件的字符串放到集合中
public List<String> filterStr(List<String> list, Predicate<String> pre){
List<String> strlist = new ArrayList<>();
for(String str:list){
if(pre.test(str)){
strlist.add(str);
}
}
return strlist;
}
}
2. Predicate的默認方法and、or、negate（取反）
public class Main{
public static void main(String[] args){
Predicate<Integer> p1 = age -> age>18;
Predicate<Integer> p2 = age -> age<30;
//其實就是表達式（age -> age>18）&&（age -> age<30）賦值給and
Predicate<Integer> and = p1.and(p2);
boolean test1 = and.test(20); //返回p1和p2的與結果
out.println(test1); //輸出true
}
}
（2）Function函數式接口
Function接口為函數型接口，該接口的抽象方法接收一個參數并且做一些處理然后返回，Function接口還附帶了一些可以和其他函數組合的默認方法（compose，andThen）。
1. Function基本使用
public class Main{
@Test
public void test(){
String newStr = steHandler("/t /t /t 朱一龍么么噠",(str)-> str.trim());
System.out.print(newStr);
String newStr1 = steHandler("朱一龍么么噠",(str)-> str.substring(0,3));
System.out.print(newStr1);
}
// 需求：用于處理字符串
public String steHandler(String str, Function<String,String> fun){
return fun.apply(str);
}
}
2. Function的默認方法andThen（協作）
public class Main{
public static void main(String[] args){
//f1參數為String，結果為Boolean
Function<String,Boolean> f1 = s1 -> s1!=null;
Function<Boolean,Integer> f2 = b -> b?1:0;
//將f1的布爾值結果作為f2函數式接口的參數來傳遞
//所以stringIntegerFunction接收值為f1的參數類型String，返回值類型為f2的返回類型Integer
Function<String,Integer> stringIntegerFunction = f1.andThen(f2);
Integer apply = stringIntegerFunction.apply("123");
out.println(apply); //輸出1
}
}
3. Function的默認方法compose（協作）
和andThen方法大同小異。
public class Main{
public static void main(String[] args){
Function<String,Boolean> f1 = s1 -> s1!=null; //f1參數為String,結果為Boolean
Function<Boolean,Integer> f2 = b -> b?1:0;
//將f1的布爾值結果作為f2函數式接口的參數來傳遞
//所以compose接收值為f1的參數類型String，返回值類型為f2的返回類型Integer
Function<String,Integer> compose= f2.compose(f1);
Integer apply = compose.apply("123");
out.println(apply); //輸出1
}
}
（3）Consumer函數式接口
Consumer是消費型接口。Consumer表示執行在單個參數上面的操作，但沒有返回值的（正如消費有去無回）。該類的源碼如下：
package java.util.function;
import java.util.Objects;
@FunctionalInterface
public interface Consumer<T> {
//該函數式接口的唯一的抽象方法，接收一個參數，沒有返回值
void accept(T t);
//在執行完調用者方法后再執行傳入參數的方法
default Consumer<T> andThen(Consumer<? super T> after) {
Objects.requireNonNull(after);
return (T t) -> { accept(t); after.accept(t); };
}
}
1. Consumer的基本使用
public class ConsumerTest {
public static void main(String[] args) {
Consumer<Integer> consumer = (x) -> {
int num = x * 2;
System.out.println(num);
};
Consumer<Integer> consumer1 = (x) -> {
int num = x * 3;
System.out.println(num);
};
consumer.andThen(consumer1).accept(10);
}
}
（4）Supplier函數式接口
Supplier接口為供給型接口。該接口不接受任何參數，返回一個任意泛型的值。該類的源碼如下：
package java.util.function;
@FunctionalInterface
public interface Supplier<T> {
T get();
}
1. supplier的基本使用
public class Main{
@Test
public void test(){
List<Integer> list = getNumList(10,()->(int)Math.random()*100);
}
// 需求：產生指定個數的整數，并放入集合中
public List<Integer> getNumList(int num, Supplier<Integer> sup){
List<Integer> list = new ArrayList<>();
for(int i=0;i<num;i++){
Integer e = sup.get();
list.add(e);
}
return list;
}
}
總結
- Function<T, R>——將T作為輸入，返回R作為輸出
- Predicate<T>——將T作為輸入，返回一個布爾值作為輸出
- Consumer<T>——將T作為輸入，不返回任何內容
- Supplier<T>——沒有輸入，返回T
- BinaryOperator<T>——將兩個T作為輸入，返回一個T作為輸出
