玩轉Java8的Stream之函數式接口

作者：佚名 2020-05-25 16:25:17

Java8Stream 作為函數式編程的一種具體實現，開發者無需關注怎么做，只需知道要做什么，各種操作符配合簡潔明了的函數式接口給開發者帶來了簡單快速處理數據的體驗。

函數式接口是伴隨著Stream的誕生而出現的，Java8Stream 作為函數式編程的一種具體實現，開發者無需關注怎么做，只需知道要做什么，各種操作符配合簡潔明了的函數式接口給開發者帶來了簡單快速處理數據的體驗。

函數式接口

什么是函數式接口？簡單來說就是只有一個抽象函數的接口。為了使得函數式接口的定義更加規范，java8 提供了@FunctionalInterface 注解告訴編譯器在編譯器去檢查函數式接口的合法性，以便在編譯器在編譯出錯時給出提示。為了更加規范定義函數接口，給出如下函數式接口定義規則：

有且僅有一個抽象函數
必須要有@FunctionalInterface 注解
可以有默認方法

可以看出函數式接口的編寫定義非常簡單，不知道大家有沒有注意到，其實我們經常會用到函數式接口，如Runnable 接口，它就是一個函數式接口：

@FunctionalInterface  
public interface Runnable {  
    /**  
     * When an object implementing interface <code>Runnable</code> is used  
     * to create a thread, starting the thread causes the object's  
     * <code>run</code> method to be called in that separately executing  
     * thread.  
     * <p>  
     * The general contract of the method <code>run</code> is that it may  
     * take any action whatsoever.  
     *  
     * @see     java.lang.Thread#run()  
     */  
    public abstract void run();  
}

過去我們會使用匿名內部類來實現線程的執行體：

new Thread(new Runnable() {  
            @Override  
            public void run() {  
                System.out.println("Hello FunctionalInterface");  
            }  
        }).start();

現在我們使用Lambda 表達式，這里函數式接口的使用沒有體現函數式編程思想，這里輸出字符到標準輸出流中，產生了副作用，起到了簡化代碼的作用，當然還有裝B。

new Thread(()->{  
           System.out.println("Hello FunctionalInterface");  
       }).start();

Java8 util.function 包下自帶了43個函數式接口，大體分為以下幾類：

Consumer 消費接口
Function 功能接口
Operator 操作接口
Predicate 斷言接口
Supplier 生產接口

其他接口都是在此基礎上變形定制化罷了。

函數式接口詳細介紹

這里只介紹最基礎的函數式接口，至于它的變體只要明白了基礎自然就能夠明白。前篇：玩轉Java8中的 Stream 之從零認識 Stream

Consumer

消費者接口，就是用來消費數據的。

@FunctionalInterface  
public interface Consumer<T> {  
    /**  
     * Performs this operation on the given argument.  
     *  
     * @param t the input argument  
     */  
    void accept(T t);  
    /** 
      * Returns a composed {@code Consumer} that performs, in sequence, this  
     * operation followed by the {@code after} operation. If performing either  
     * operation throws an exception, it is relayed to the caller of the  
     * composed operation.  If performing this operation throws an exception,  
     * the {@code after} operation will not be performed.  
     *  
     * @param after the operation to perform after this operation  
     * @return a composed {@code Consumer} that performs in sequence this  
     * operation followed by the {@code after} operation  
     * @throws NullPointerException if {@code after} is null  
     */  
    default Consumer<T> andThen(Consumer<? super T> after) {  
        Objects.requireNonNull(after);  
        return (T t) -> { accept(t); after.accept(t); };  
    }  
}

Consumer 接口中有accept 抽象方法，accept接受一個變量，也就是說你在使用這個函數式接口的時候，給你提供了數據，你只要接收使用就可以了；andThen 是一個默認方法，接受一個Consumer 類型，當你對一個數據使用一次還不夠爽的時候，你還能再使用一次，當然你其實可以爽無數次，只要一直使用andThan方法。

Function

何為Function呢？比如電視機，給你帶來精神上的愉悅，但是它需要用電啊，電視它把電轉換成了你荷爾蒙，這就是Function，簡單電說，Function 提供一種轉換功能。

@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);  
    /**  
     * Returns a composed function that first applies the {@code before}  
     * function to its input, and then applies this function to the result.  
     * If evaluation of either function throws an exception, it is relayed to  
     * the caller of the composed function.  
     *  
     * @param <V> the type of input to the {@code before} function, and to the  
     *           composed function  
     * @param before the function to apply before this function is applied  
     * @return a composed function that first applies the {@code before}  
     * function and then applies this function  
     * @throws NullPointerException if before is null  
     *  
     * @see #andThen(Function)  
     */  
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {  
        Objects.requireNonNull(before);  
        return (V v) -> apply(before.apply(v));  
    }  
    /**  
     * Returns a composed function that first applies this function to  
     * its input, and then applies the {@code after} function to the result.  
     * If evaluation of either function throws an exception, it is relayed to  
     * the caller of the composed function.  
     *  
     * @param <V> the type of output of the {@code after} function, and of the  
     *           composed function  
     * @param after the function to apply after this function is applied  
     * @return a composed function that first applies this function and then  
     * applies the {@code after} function  
     * @throws NullPointerException if after is null  
     *  
     * @see #compose(Function)  
     */  
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {  
        Objects.requireNonNull(after);  
        return (T t) -> after.apply(apply(t));  
    }  
    /**  
     * Returns a function that always returns its input argument.  
     *  
     * @param <T> the type of the input and output objects to the function  
     * @return a function that always returns its input argument  
     */  
    static <T> Function<T, T> identity() {  
        return t -> t;  
    }  
}

Function 接口最主要的就是apply 函數，apply 接受T類型數據并返回R類型數據，就是將T類型的數據轉換成R類型的數據，它還提供了compose、andThen、identity 三個默認方法，compose 接受一個Function，andThen也同樣接受一個Function，這里的andThen 與Consumer 的andThen 類似，在apply之后在apply一遍，compose 則與之相反，在apply之前先apply（這兩個apply具體處理內容一般是不同的），identity 起到了類似海關的作用，外國人想要運貨進來，總得交點稅吧，然后貨物才能安全進入中國市場，當然了想不想收稅還是你說了算的:。

Operator

可以簡單理解成算術中的各種運算操作，當然不僅僅是運算這么簡單，因為它只定義了運算這個定義，但至于運算成什么樣你說了算。由于沒有最基礎的Operator，這里將通過 BinaryOperator、IntBinaryOperator來理解Operator 函數式接口，先從簡單的IntBinaryOperator開始。

IntBinaryOperator

從名字可以知道，這是一個二元操作，并且是Int 類型的二元操作，那么這個接口可以做什么呢，除了加減乘除，還可以可以實現平方（兩個相同int 數操作起來不就是平方嗎），還是先看看它的定義吧：

@FunctionalInterface  
public interface IntBinaryOperator {  
    /**  
     * Applies this operator to the given operands. 
     *  
     * @param left the first operand 
     * @param right the second operand  
     * @return the operator result  
     */  
    int applyAsInt(int left, int right);  
}

IntBinaryOperator 接口內只有一個applyAsInt 方法，其接收兩個int 類型的參數，并返回一個int 類型的結果，其實這個跟Function 接口的apply 有點像，但是這里限定了，只能是int類型。

BinaryOperator

BinaryOperator 二元操作，看起來它和IntBinaryOperator 是父子關系，實際上這兩者沒有半點關系，但他們在功能上還是有相似之處的：

@FunctionalInterface  
public interface BinaryOperator<T> extends BiFunction<T,T,T> {  
    /**  
     * Returns a {@link BinaryOperator} which returns the lesser of two elements  
     * according to the specified {@code Comparator}. 
     *  
     * @param <T> the type of the input arguments of the comparator  
     * @param comparator a {@code Comparator} for comparing the two values  
     * @return a {@code BinaryOperator} which returns the lesser of its operands,  
     *         according to the supplied {@code Comparator}  
     * @throws NullPointerException if the argument is null  
     */  
    public static <T> BinaryOperator<T> minBy(Comparator<? super T> comparator) {  
        Objects.requireNonNull(comparator);  
        return (a, b) -> comparator.compare(a, b) <= 0 ? a : b;  
    }  
    /**  
     * Returns a {@link BinaryOperator} which returns the greater of two elements  
     * according to the specified {@code Comparator}.  
     *  
     * @param <T> the type of the input arguments of the comparator  
     * @param comparator a {@code Comparator} for comparing the two values  
     * @return a {@code BinaryOperator} which returns the greater of its operands,  
     *         according to the supplied {@code Comparator}  
     * @throws NullPointerException if the argument is null  
     */  
    public static <T> BinaryOperator<T> maxBy(Comparator<? super T> comparator) {  
        Objects.requireNonNull(comparator);  
        return (a, b) -> comparator.compare(a, b) >= 0 ? a : b;  
    }  
}

BinaryOperator 是 BiFunction 生的，而IntBinaryOperator 是從石頭里蹦出來的，BinaryOperator 自身定義了minBy、maxBy默認方法，并且參數都是Comparator，就是根據傳入的比較器的比較規則找出最小最大的數據。

Predicate

斷言、判斷，對輸入的數據根據某種標準進行評判，最終返回boolean值：

@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);  
    /**  
     * Returns a composed predicate that represents a short-circuiting logical  
     * AND of this predicate and another.  When evaluating the composed  
     * predicate, if this predicate is {@code false}, then the {@code other}  
     * predicate is not evaluated.  
     *  
     * <p>Any exceptions thrown during evaluation of either predicate are relayed  
     * to the caller; if evaluation of this predicate throws an exception, the  
     * {@code other} predicate will not be evaluated.  
     *  
     * @param other a predicate that will be logically-ANDed with this  
     *              predicate  
     * @return a composed predicate that represents the short-circuiting logical  
     * AND of this predicate and the {@code other} predicate  
     * @throws NullPointerException if other is null  
     */  
    default Predicate<T> and(Predicate<? super T> other) {  
        Objects.requireNonNull(other);  
        return (t) -> test(t) && other.test(t);  
    }  
    /**  
     * Returns a predicate that represents the logical negation of this  
     * predicate.  
     *  
     * @return a predicate that represents the logical negation of this  
     * predicate  
     */  
    default Predicate<T> negate() {  
        return (t) -> !test(t);  
    }  
    /**  
     * Returns a composed predicate that represents a short-circuiting logical  
     * OR of this predicate and another.  When evaluating the composed  
     * predicate, if this predicate is {@code true}, then the {@code other}  
     * predicate is not evaluated.  
     *  
     * <p>Any exceptions thrown during evaluation of either predicate are relayed  
     * to the caller; if evaluation of this predicate throws an exception, the  
     * {@code other} predicate will not be evaluated.  
     *  
     * @param other a predicate that will be logically-ORed with this  
     *              predicate  
     * @return a composed predicate that represents the short-circuiting logical  
     * OR of this predicate and the {@code other} predicate  
     * @throws NullPointerException if other is null  
     */  
    default Predicate<T> or(Predicate<? super T> other) {  
        Objects.requireNonNull(other);  
        return (t) -> test(t) || other.test(t);  
    }  
    /**  
     * Returns a predicate that tests if two arguments are equal according  
     * to {@link Objects#equals(Object, Object)}.  
     *  
     * @param <T> the type of arguments to the predicate  
     * @param targetRef the object reference with which to compare for equality,  
     *               which may be {@code null}  
     * @return a predicate that tests if two arguments are equal according  
     * to {@link Objects#equals(Object, Object)}  
     */  
    static <T> Predicate<T> isEqual(Object targetRef) {  
        return (null == targetRef)  
                ? Objects::isNull  
                : object -> targetRef.equals(object);  
    }  
}

Predicate的test 接收T類型的數據，返回 boolean 類型，即對數據進行某種規則的評判，如果符合則返回true，否則返回false；Predicate接口還提供了 and、negate、or，與取反或等，isEqual 判斷兩個參數是否相等等默認函數。

Supplier

生產、提供數據：

@FunctionalInterface  
public interface Supplier<T> {  
    /**  
     * Gets a result.  
     *  
     * @return a result  
     */  
    T get();  
}

非常easy，get方法返回一個T類數據，可以提供重復的數據，或者隨機種子都可以，就這么簡單。

函數式接口實戰

Consumer

Consumer 用的太多了，不想說太多，如下：

public class Main {  
    public static void main(String[] args) {  
      Stream.of(1,2,3,4,5,6) 
                 .forEach(integer -> System.out.println(integer)); //輸出1，2，3，4，5，6  
    }  
}

這里使用標準輸出，還是產生了副作用，但是這種程度是可以允許的

Function

1.轉換，將字符串轉成長度

public class Main {  
    public static void main(String[] args) {  
       Stream.of("hello","FunctionalInterface")  
                .map(e->e.length())  
                .forEach(System.out::println);  
    }  
}

2.運算

public class FunctionTest {  
    public static void main(String[] args) {  
         public static void main(String[] args) {  
        Function<Integer, Integer> square = integer -> integer * integer; //定義平方運算  
        List<Integer> list = new ArrayList<>();  
        list.add(1);  
        list.add(2);  
        list.add(3);  
        list.add(4); 
        list.stream()  
                .map(square.andThen(square)) //四次方  
                .forEach(System.out::println); 
        System.out.println("------");  
        list.stream()  
                .map(square.compose(e -> e - 1)) //減一再平方  
                .forEach(System.out::println);  
        System.out.println("------");  
        list.stream().map(square.andThen(square.compose(e->e/2))) //先平方然后除2再平方  
                .forEach(System.out::println);  
    }  
}

結果如圖：

Operator

1.BinaryOperator

這里實現找最大值：

public class BinaryOperatorTest {  
    public static void main(String[] args) {  
        Stream.of(2,4,5,6,7,1) 
                 .reduce(BinaryOperator.maxBy(Comparator.comparingInt(Integer::intValue))).ifPresent(System.out::println);  
    }  
}

Comparator 后期會講到

2.IntOperator

這里實現累加功能：

public class BinaryOperatorTest {  
    public static void main(String[] args) {  
        IntBinaryOperator intBinaryOperator = (e1, e2)->e1+e2; //定義求和二元操作  
        IntStream.of(2,4,5,6,7,1) 
                 .reduce(intBinaryOperator).ifPresent(System.out::println); 
     }  
}

Predicate

篩選出大于0最小的兩個數

public class Main {  
    public static void main(String[] args) {  
        IntStream.of(200,45,89,10,-200,78,94)  
                .filter(e->e>0) //過濾小于0的數  
                .sorted() //自然順序排序  
                .limit(2) //取前兩個  
                .forEach(System.out::println);  
    }  
}

Supplier

這里一直生產2這個數字，為了能停下來，使用limit

public class Main {  
    public static void main(String[] args) {  
        Stream.generate(()->2)  
                .limit(10)  
                .forEach(System.out::println);  
    }  
}

如圖：

總結

Java8的Stream 基本上都是使用util.function包下的函數式接口來實現函數式編程的，而函數式接口也就只分為 Function、Operator、Consumer、Predicate、Supplier 這五大類，只要能理解掌握最基礎的五大類用法，其他變種也能觸類旁通。

責任編輯：龐桂玉來源： Java知音