Java8的新特性--函式式介面

是倩倩不是欠欠發表於2021-03-07
Java函式

目錄

函式式介面

Lambda表示式需要介面的支援，並且介面的抽象方法還只能有一個，要麼沒法區分實現的是哪一個抽象方法了。因此Lambda表示式需要函式式介面的支援

什麼是函式式介面

介面中只有一個抽象方法的介面稱為函式式介面。

函式式介面可以使用一個註解@FunctionalInterface修飾，此註解可以檢查是否是函式式介面

函式式介面的使用

假設我們現在有一個需求：對一個數進行運算，什麼運算都可以。如果我們想用Lambda表示式來實現的話，我們就需要一個介面來支援，下面我們先寫一個MyFunction介面

@FunctionalInterface
public interface MyFunction {
    public Integer getValue(Integer num);
}

然後我們需要一個運算的方法

    //運算方法
    public Integer operation(Integer num, MyFunction fun){
        return fun.getValue(num);
    }

測試類

    @Test
    public void test06(){
        //平方運算
        Integer num = operation(10,(x) -> x*x);
        System.out.println(num);
        //加和運算
        Integer num2 = operation(100,(y) -> y+200);
        System.out.println(num2);

    }

執行結果

100
300

不管是什麼運算，我們只需要關注Lambda表示式的方法體如何實現運算就可以了。

通過以上例子發現，如果我們想用Lambda表示式來實現的話，我們就需要寫一個介面來支援，是不是也挺麻煩的，其實，一般我們常用的介面，Java8裡基本都已經給我們提供了，下面來看下Java8內建的核心介面。

Java8內建的四大核心函式式介面

一、Consumer：消費型介面（void accept(T t)）

我們先看一下Java8中給我定義好的Consumer介面

@FunctionalInterface
public interface Consumer<T> {

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

    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

然後我們自己寫個簡單的例子看一下，寫個開開森森去消費的方法

    @Test
    public void test01(){
        happy("一消費就很開森啦啦啦",str -> System.out.println(str));
    }
    public void happy(String str,Consumer<String> consumer){
        consumer.accept(str);
    }

執行結果

一消費就很開森啦啦啦

以上就是消費型介面，消費即是有去無回，有引數無返回值型別的介面。

二、Supplier：供給型介面（T get（））

我們先看一下Java8中給我定義好的Supplier介面

@FunctionalInterface
public interface Supplier<T> {

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

我們再來寫個例子，寫個方法產生指定個數的整數並放入集合中

    @Test
    public void test02(){
        List<Integer> numList = getValue(10,() -> (int)(Math.random()*100));
        for (Integer num :
                numList) {
            System.out.println(num);
        }
    }

    //產生指定個數的整數並放入集合中
    public List<Integer> getValue(int num,Supplier<Integer> supplier){
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < num; i++) {
            list.add(supplier.get());
        }
        return list;
    }

執行結果

84
22
60
29
52
34
9
95
34
6

以上就是供給型介面，只有產出，沒有輸入，即只有返回值沒有入參，給你產生一些物件，並返回給你。

三、Function : 函式型介面（R apply（T t））

Java8中函式式介面的定義

@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);
    
    ····後面程式碼省略了····
    }

下面寫個處理字串方法的例子

    @Test
    public void test03(){
        String returnStr = strHandler("\t\t\t我是一串有空格\t的字串\t\t",(str) -> str.trim());
        System.out.println(returnStr);
    }

    public String strHandler(String str,Function<String,String> function){
        return function.apply(str);
    }

執行結果：trim()方法只是去除首尾的字串

我是一串有空格	的字串

以上就是一個函式型介面，一個引數，一個返回值，當然引數和返回值的型別可以相同

四、Predicate：斷言型介面（boolean test（T t））

Java8中斷言型介面的定義如下

@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);
    ····後面到嗎省略····
    }

下面我們寫一個斷言的例子，寫個方法將滿足條件的字串放入集合中

    @Test
    public void test04(){
        List<String> list = Arrays.asList("aa","bbb","ccccc","dddddd");
        //長度大於3的字串放入集合中
        List<String> reList = filterStr(list,(s) -> s.length() >3);
        for (String str: reList) {
            System.out.println(str);
        }
    }

    public List<String> filterStr(List<String> strList,Predicate<String> pre){
        List<String> list = new ArrayList<>();
        for (String str: strList) {
            if(pre.test(str)){
                list.add(str);
            }
        }
        return list;
    }

執行結果

ccccc
dddddd

以上是斷言型介面，輸入一個引數，輸出一個boolean型別的返回值

五、其他型別的一些函式式介面

除了上面四種型別的核心介面還有一些其他的不常用的介面，我們可以瞭解一下

  1. BiFunction<T, U, R>
  • 型別：引數型別T，U返回型別R
  • 用途：Function的子介面，對型別為T和U的引數應用操作，返回R型別的結果。包含有方法R apply(T t,U u)
  1. UnaryOperator(Function子介面)
  • 型別：引數型別T,返回型別T
  • 用途：Function的子介面，對型別為T的物件進行一元運算，並返回T型別的結果。包含有方法T apply(T t)
  1. BinaryOperator(BiFunction子介面)
  • 型別：引數型別T，T,返回型別T
  • 用途：BiFunction的子介面，對型別為T的物件進行二元運算，並返回T型別的結果。包含有方法T apply(T t1,T t2)
  1. BiConsumcr(T, U)
  • 型別：引數型別T, U,返回型別void
  • 用途：Consumcr的子介面，對型別為T,U的引數應用操作。包含有方法void accept(T t,U u)
  1. ToIntFunction、ToLongFunction、ToDoubleFunction
  • 型別：引數型別T,返回型別int long double
  • 用途：分別計算int long double值的函式
  1. IntFunction、LongFunction、DoubleFunction
  • 型別：引數型別int long double,返回型別T
  • 用途：引數分別為int long double型別的函式

總結

以上就是Java8內建的核心介面，我們在使用的過程中，按需所取就ok啦。

相關文章