樂字節-Java8新特性之函數式接口

上一篇小樂帶你們學過 Java8新特性-Lambda表達式，何時可使用Lambda？一般Lambda表達式是用在函數式接口上使用的。從Java8開始引入了函數式接口，其說明比較簡單:函數式接口(Functional Interface)就是一個有且僅有一個抽象方法，可是能夠有多個非抽象方法的接口。 java8引入@FunctionalInterface 註解聲明該接口是一個函數式接口。

一、語法定義

/**
 * 定義函數式接口
 * 接口上標註@FunctionalInterface 註解
 */
@FunctionalInterface
public interface ICollectionService {
    /**
     * 定義打印方法
     */
    void print();
}

在Java8 之前，已有大量函數式接口形式的接口（接口中只存在一個抽象方法），只是沒有強制聲明。例如:

• java.lang.Runnable
• java.util.concurrent.Callable
• java.security.PrivilegedAction
• java.io.FileFilter
• java.nio.file.PathMatcher
• java.lang.reflect.InvocationHandler
• java.beans.PropertyChangeListener
• java.awt.event.ActionListener
• javax.swing.event.ChangeListener

Java8 新增長的函數接口在java.util.function 包下，它包含了不少類，用來支持 Java的 函數式編程，該包中的函數式接口有：

序號 接口 & 描述
1 BiConsumer<T,U>表明了一個接受兩個輸入參數的操做，而且不返回任何結果
2 BiFunction<T,U,R>表明了一個接受兩個輸入參數的方法，而且返回一個結果
3 BinaryOperator<T>表明了一個做用於於兩個同類型操做符的操做，而且返回了操做符同類型的結果
4 BiPredicate<T,U>表明了一個兩個參數的boolean值方法
5 BooleanSupplier表明了boolean值結果的提供方
6 Consumer<T>表明了接受一個輸入參數而且無返回的操做
7 DoubleBinaryOperator表明了做用於兩個double值操做符的操做，而且返回了一個double值的結果。
8 DoubleConsumer表明一個接受double值參數的操做，而且不返回結果。
9 DoubleFunction<R>表明接受一個double值參數的方法，而且返回結果
10 DoublePredicate表明一個擁有double值參數的boolean值方法
11 DoubleSupplier表明一個double值結構的提供方
12 DoubleToIntFunction接受一個double類型輸入，返回一個int類型結果。
13 DoubleToLongFunction接受一個double類型輸入，返回一個long類型結果
14 DoubleUnaryOperator接受一個參數同爲類型double,返回值類型也爲double 。
15 Function<T,R>接受一個輸入參數，返回一個結果。
16 IntBinaryOperator接受兩個參數同爲類型int,返回值類型也爲int 。
17 IntConsumer接受一個int類型的輸入參數，無返回值 。
18 IntFunction<R>接受一個int類型輸入參數，返回一個結果 。
19 IntPredicate：接受一個int輸入參數，返回一個布爾值的結果。
20 IntSupplier無參數，返回一個int類型結果。
21 IntToDoubleFunction接受一個int類型輸入，返回一個double類型結果 。
22 IntToLongFunction接受一個int類型輸入，返回一個long類型結果。
23 IntUnaryOperator接受一個參數同爲類型int,返回值類型也爲int 。
24 LongBinaryOperator接受兩個參數同爲類型long,返回值類型也爲long。
25 LongConsumer接受一個long類型的輸入參數，無返回值。
26 LongFunction<R>接受一個long類型輸入參數，返回一個結果。
27 LongPredicateR接受一個long輸入參數，返回一個布爾值類型結果。
28 LongSupplier無參數，返回一個結果long類型的值。
29 LongToDoubleFunction接受一個long類型輸入，返回一個double類型結果。
30 LongToIntFunction接受一個long類型輸入，返回一個int類型結果。
31 LongUnaryOperator接受一個參數同爲類型long,返回值類型也爲long。
32 ObjDoubleConsumer<T>接受一個object類型和一個double類型的輸入參數，無返回值。
33 ObjIntConsumer<T>接受一個object類型和一個int類型的輸入參數，無返回值。
34 ObjLongConsumer<T>接受一個object類型和一個long類型的輸入參數，無返回值。
35 Predicate<T>接受一個輸入參數，返回一個布爾值結果。
36 Supplier<T>無參數，返回一個結果。
37 ToDoubleBiFunction<T,U>接受兩個輸入參數，返回一個double類型結果
38 ToDoubleFunction<T>接受一個輸入參數，返回一個double類型結果
39 ToIntBiFunction<T,U>接受兩個輸入參數，返回一個int類型結果。
40 ToIntFunction<T>接受一個輸入參數，返回一個int類型結果。
41 ToLongBiFunction<T,U>接受兩個輸入參數，返回一個long類型結果。
42 ToLongFunction<T>接受一個輸入參數，返回一個long類型結果。
43 UnaryOperator<T>接受一個參數爲類型T,返回值類型也爲T。

對於Java8中提供的這麼多函數式接口，開發中經常使用的函數式接口有如下幾個

Predicate，Consumer，Function，Supplier。

二、函數式接口實例

2.一、Predicate

java.util.function.Predicate<T> 接口定義了一個名叫 test 的抽象方法，它接受泛型 T 對象，並返回一個boolean值。在對類型 T進行斷言判斷時，可使用這個接口。一般稱爲斷言性接口 。

使用Predicate接口實現字符串判空操做

@FunctionalInterface
public interface Predicate<T> {

    /**
     * Evaluates this predicate on the given argument.
     *
     * @param t the input argument
     * @return {@code true} if the input argument matches the predicate,
     * otherwise {@code false}
     */
    boolean test(T t);
    ...
}

public static void main(String[] args) {
    /**
      * 藉助Lambda  表達式實現Predicate test方法
        */
    Predicate<String> p01=(str)->str.isEmpty()||str.trim().isEmpty();
    /**
     * 測試傳入的字符串是否爲空
      */
    System.out.println(p01.test(""));
    System.out.println(p01.test("  "));
    System.out.println(p01.test("admin"));
}

測試代碼

public static void main(String[] args) {
    /**
      * 藉助Lambda  表達式實現Predicate test方法
        */
    Predicate<String> p01=(str)->str.isEmpty()||str.trim().isEmpty();
    /**
     * 測試傳入的字符串是否爲空
      */
    System.out.println(p01.test(""));
    System.out.println(p01.test("  "));
    System.out.println(p01.test("admin"));
}

測試結果:

2.二、Consumer

java.util.function.Consumer<T>接口定義了一個名叫 accept 的抽象方法，它接受泛型T，沒有返回值(void)。若是須要訪問類型 T 的對象，並對其執行某些操做，可使用這個接口，一般稱爲消費性接口。

使用Consumer實現集合遍歷操做

@FunctionalInterface
public interface Consumer<T> {

    /**
     * Performs this operation on the given argument.
     *
     * @param t the input argument
     */
    void accept(T t);
    ...
}


/**
* 藉助Lambda表達式實現Consumer  accept方法
*/
Consumer<Collection> c01 = (collection) -> {
if (null != collection && collection.size() > 0) {
for (Object c : collection) {
System.out.println(c);
}
}
};

List<String> list = new ArrayList<String>();
list.add("諸葛亮");
list.add("曹操");
list.add("關羽");

// 遍歷list 輸出元素內容到控制檯
c01.accept(list);

2.三、Function

java.util.function.Function<T, R>接口定義了一個叫做apply的方法，它接受一個泛型T的對象，並返回一個泛型R的對象。若是須要定義一個Lambda，將輸入的信息映射到輸出，可使用這個接口(好比提取蘋果的重量，或把字符串映射爲它的長度),一般稱爲功能性接口。

使用Function實現用戶密碼 Base64加密操做

@FunctionalInterface
public interface Function<T, R> {

    /**
     * Applies this function to the given argument.
     *
     * @param t the function argument
     * @return the function result
     */
    R apply(T t);
}


// 實現用戶密碼 Base64加密操做
Function<String,String> f01=(password)->Base64.getEncoder().encodeToString(password.getBytes());
// 輸出加密後的字符串
System.out.println(f01.apply("123456"));

加密後結果以下:

2.四、Supplier

java.util.function.Supplier<T>接口定義了一個get的抽象方法，它沒有參數，返回一個泛型T的對象，這相似於一個工廠方法,一般稱爲功能性接口。

使用Supplier實現SessionFactory建立

@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

/**
 * 產生一個session工廠對象
 */
Supplier<SessionFactory> s = () -> {
    return new SessionFactory();
};

s.get().info();

以上就是小樂帶給你們的Java8新特性之函數式接口，下一篇將會爲你們帶來Java8新特性之方法引用，敬請關注。

轉載請註明文章出處和做者，謝謝合做！