這期內(nèi)容當(dāng)中小編將會(huì)給大家?guī)碛嘘P(guān)Java8中怎么利用Stream實(shí)現(xiàn)函數(shù)式接口，文章內(nèi)容豐富且以專業(yè)的角度為大家分析和敘述，閱讀完這篇文章希望大家可以有所收獲。

創(chuàng)新互聯(lián)公司是一家專注于做網(wǎng)站、成都網(wǎng)站制作與策劃設(shè)計(jì),南城網(wǎng)站建設(shè)哪家好?創(chuàng)新互聯(lián)公司做網(wǎng)站,專注于網(wǎng)站建設(shè)10多年,網(wǎng)設(shè)計(jì)領(lǐng)域的專業(yè)建站公司;建站業(yè)務(wù)涵蓋:南城等地區(qū)。南城做網(wǎng)站價(jià)格咨詢:028-86922220

函數(shù)式接口

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

•  有且僅有一個(gè)抽象函數(shù)

•  必須要有@FunctionalInterface 注解

•  可以有默認(rèn)方法

可以看出函數(shù)式接口的編寫定義非常簡(jiǎn)單，不知道大家有沒有注意到，其實(shí)我們經(jīng)常會(huì)用到函數(shù)式接口，如Runnable 接口，它就是一個(gè)函數(shù)式接口：

@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();  }

過去我們會(huì)使用匿名內(nèi)部類來實(shí)現(xiàn)線程的執(zhí)行體：

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

現(xiàn)在我們使用Lambda 表達(dá)式，這里函數(shù)式接口的使用沒有體現(xiàn)函數(shù)式編程思想，這里輸出字符到標(biāo)準(zhǔn)輸出流中，產(chǎn)生了副作用，起到了簡(jiǎn)化代碼的作用，當(dāng)然還有裝B。

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

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

•  Consumer 消費(fèi)接口

•  Function 功能接口

•  Operator 操作接口

•  Predicate 斷言接口

•  Supplier 生產(chǎn)接口

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

函數(shù)式接口詳細(xì)介紹

這里只介紹最基礎(chǔ)的函數(shù)式接口，至于它的變體只要明白了基礎(chǔ)自然就能夠明白。前篇：玩轉(zhuǎn)Java8中的 Stream 之從零認(rèn)識(shí) Stream

Consumer

消費(fèi)者接口，就是用來消費(fèi)數(shù)據(jù)的。

@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接受一個(gè)變量，也就是說你在使用這個(gè)函數(shù)式接口的時(shí)候，給你提供了數(shù)據(jù)，你只要接收使用就可以了；andThen 是一個(gè)默認(rèn)方法，接受一個(gè)Consumer 類型，當(dāng)你對(duì)一個(gè)數(shù)據(jù)使用一次還不夠爽的時(shí)候，你還能再使用一次，當(dāng)然你其實(shí)可以爽無數(shù)次，只要一直使用andThan方法。

Function

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

@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 函數(shù)，apply 接受T類型數(shù)據(jù)并返回R類型數(shù)據(jù)，就是將T類型的數(shù)據(jù)轉(zhuǎn)換成R類型的數(shù)據(jù)，它還提供了compose、andThen、identity 三個(gè)默認(rèn)方法，compose 接受一個(gè)Function，andThen也同樣接受一個(gè)Function，這里的andThen 與Consumer 的andThen 類似，在apply之后在apply一遍，compose 則與之相反，在apply之前先apply（這兩個(gè)apply具體處理內(nèi)容一般是不同的），identity 起到了類似海關(guān)的作用，外國人想要運(yùn)貨進(jìn)來，總得交點(diǎn)稅吧，然后貨物才能安全進(jìn)入中國市場(chǎng)，當(dāng)然了想不想收稅還是你說了算的:。

Operator

可以簡(jiǎn)單理解成算術(shù)中的各種運(yùn)算操作，當(dāng)然不僅僅是運(yùn)算這么簡(jiǎn)單，因?yàn)樗欢x了運(yùn)算這個(gè)定義，但至于運(yùn)算成什么樣你說了算。由于沒有最基礎(chǔ)的Operator，這里將通過 BinaryOperator、IntBinaryOperator來理解Operator 函數(shù)式接口，先從簡(jiǎn)單的IntBinaryOperator開始。

IntBinaryOperator

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

@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 接口內(nèi)只有一個(gè)applyAsInt 方法，其接收兩個(gè)int 類型的參數(shù)，并返回一個(gè)int 類型的結(jié)果，其實(shí)這個(gè)跟Function 接口的apply 有點(diǎn)像，但是這里限定了，只能是int類型。

BinaryOperator

BinaryOperator 二元操作，看起來它和IntBinaryOperator 是父子關(guān)系，實(shí)際上這兩者沒有半點(diǎn)關(guān)系，但他們?cè)诠δ苌线€是有相似之處的：

@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默認(rèn)方法，并且參數(shù)都是Comparator，就是根據(jù)傳入的比較器的比較規(guī)則找出最小最大的數(shù)據(jù)。

Predicate

斷言、判斷，對(duì)輸入的數(shù)據(jù)根據(jù)某種標(biāo)準(zhǔn)進(jìn)行評(píng)判，最終返回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類型的數(shù)據(jù)，返回 boolean 類型，即對(duì)數(shù)據(jù)進(jìn)行某種規(guī)則的評(píng)判，如果符合則返回true，否則返回false；Predicate接口還提供了 and、negate、or，與 取反 或等，isEqual 判斷兩個(gè)參數(shù)是否相等等默認(rèn)函數(shù)。

Supplier

生產(chǎn)、提供數(shù)據(jù)：

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

非常easy，get方法返回一個(gè)T類數(shù)據(jù)，可以提供重復(fù)的數(shù)據(jù)，或者隨機(jī)種子都可以，就這么簡(jiǎn)單。

函數(shù)式接口實(shí)戰(zhàn)

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      }  }

這里使用標(biāo)準(zhǔn)輸出，還是產(chǎn)生了副作用，但是這種程度是可以允許的

Function

1.轉(zhuǎn)換，將字符串轉(zhuǎn)成長度

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

2.運(yùn)算

public class FunctionTest {      public static void main(String[] args) {           public static void main(String[] args) {          Function<Integer, Integer> square = integer -> integer * integer; //定義平方運(yùn)算          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);      }  }

結(jié)果如圖：

Operator

1.BinaryOperator

這里實(shí)現(xiàn)找最大值：

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 后期會(huì)講到

2.IntOperator

這里實(shí)現(xiàn)累加功能：

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最小的兩個(gè)數(shù)

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

Supplier

這里一直生產(chǎn)2這個(gè)數(shù)字，為了能停下來，使用limit

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

如圖：

上述就是小編為大家分享的Java8中怎么利用Stream實(shí)現(xiàn)函數(shù)式接口了，如果剛好有類似的疑惑，不妨參照上述分析進(jìn)行理解。如果想知道更多相關(guān)知識(shí)，歡迎關(guān)注創(chuàng)新互聯(lián)行業(yè)資訊頻道。

網(wǎng)站題目：Java8中怎么利用Stream實(shí)現(xiàn)函數(shù)式接口
分享網(wǎng)址：http://jinyejixie.com/article38/iisipp.html

成都網(wǎng)站建設(shè)公司_創(chuàng)新互聯(lián)，為您提供響應(yīng)式網(wǎng)站、定制開發(fā)、網(wǎng)站建設(shè)、外貿(mào)網(wǎng)站建設(shè)、ChatGPT、網(wǎng)站排名

廣告

聲明：本網(wǎng)站發(fā)布的內(nèi)容（圖片、視頻和文字）以用戶投稿、用戶轉(zhuǎn)載內(nèi)容為主，如果涉及侵權(quán)請(qǐng)盡快告知，我們將會(huì)在第一時(shí)間刪除。文章觀點(diǎn)不代表本網(wǎng)站立場(chǎng)，如需處理請(qǐng)聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內(nèi)容未經(jīng)允許不得轉(zhuǎn)載，或轉(zhuǎn)載時(shí)需注明來源： 創(chuàng)新互聯(lián)