文章內容整理自 博學谷狂野架構師
概述
什么是函式式介面？簡單來說就是只有一個抽象函式的介面，為了使得函式式介面的定義更加規范，java8 提供了@FunctionalInterface 注解告訴編譯器在編譯器去檢查函式式介面的合法性，以便在編譯器在編譯出錯時給出提示，為了更加規范定義函式介面，給出如下函式式介面定義規則：
- 有且僅有一個抽象函式
- 必須要有@FunctionalInterface 注解
- 可以有默認方法
可以看出函式式介面的撰寫定義非常簡單，不知道大家有沒有注意到，其實我們經常會用到函式式介面，如Runnable 介面，它就是一個函式式介面：
COPY@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();
}
過去我們會使用匿名內部類來實作執行緒的執行體：
COPYnew Thread(new Runnable() {
@Override
public void run() {
System.out.println("Hello FunctionalInterface");
}
}).start();
現在我們使用Lambda 運算式，這里函式式介面的使用沒有體現函式式編程思想，這里輸出字符到標準輸出流中，產生了副作用，起到了簡化代碼的作用，當然還有裝B，
COPYnew Thread(()->{
System.out.println("Hello FunctionalInterface");
}).start();
Java8 util.function 包下自帶了43個函式式介面，大體分為以下幾類：
- Consumer 消費介面
- Function 功能介面
- Operator 操作介面
- Predicate 斷言介面
- Supplier 生產介面
其他介面都是在此基礎上變形定制化罷了，
函式式介面詳細介紹
這里只介紹最基礎的函式式介面，至于它的變體只要明白了基礎自然就能夠明白
Consumer
消費者介面，就是用來消費資料的，
COPY@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 提供一種轉換功能，
COPY@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 是父子關系，實際上這兩者沒有半點關系，但他們在功能上還是有相似之處的：
COPY@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值：
COPY@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
生產、提供資料：
COPY@FunctionalInterface
public interface Supplier<T> {
/**
* Gets a result.
*
* @return a result
*/
T get();
}
非常easy，get方法回傳一個T類資料，可以提供重復的資料，或者隨機種子都可以，就這么簡單，
函式式介面實戰
Consumer
Consumer 用的太多了，不想說太多，如下：
COPYpublic 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
轉換，將字串轉成長度
COPYpublic class Main {
public static void main(String[] args) {
Stream.of("hello","FunctionalInterface")
.map(e->e.length())
.forEach(System.out::println);
}
}
運算
COPYpublic 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);
}
}
結果如下
COPY1
16
81
256
------
0
1
4
9
------
0
4
16
64
Operator
BinaryOperator
這里實作找最大值：
COPYpublic 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);
}
}
IntOperator
這里實作累加功能：
COPYpublic 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最小的兩個數
COPYpublic 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
COPYpublic class Main {
public static void main(String[] args) {
Stream.generate(()->2)
.limit(10)
.forEach(System.out::println);
}
}
輸出結果
COPY2
2
2
2
2
2
2
2
2
2
總結
Java8的Stream 基本上都是使用util.function包下的函式式介面來實作函式式編程的，而函式式介面也就只分為 Function、Operator、Consumer、Predicate、Supplier 這五大類，只要能理解掌握最基礎的五大類用法，其他變種也能觸類旁通，
本文由
傳智教育博學谷狂野架構師教研團隊發布，如果本文對您有幫助，歡迎
關注和點贊；如果您有任何建議也可留言評論或私信，您的支持是我堅持創作的動力，轉載請注明出處！
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/543864.html
標籤：其他
上一篇：Acwing 327. 玉米田