Java8新特性學習-函數式接口

時間 2019-12-07

標籤 java8 java 特性學習函數接口欄目 Java 简体版

原文原文鏈接

Java8新特性學習😝

Java你們庭已經出到11版本了，我還在使用jdk7=-=，再不學就來不及了，因此趕忙學一下Java8的新特性。html

介紹

函數式接口(Functional Interface)就是一個有且僅有一個抽象方法，可是能夠有多個非抽象方法的接口java

函數式接口在java.util.function路徑下。git

在這個包中，每個接口都被@FunctionalInterface標註，表示這個類是一個函數式接口，主要用於編譯級錯誤檢查，加上該註解，當你寫的接口不符合函數式接口定義的時候，編譯器會報錯。-- 摘錄自菜鳥編程github

具體使用

此次咱們簡單粗暴一下，貼出測試代碼，看下具體使用場景和用法吧編程

在每一個方法中都寫上了註解app

package com.example.demo;

import com.example.demo.test.Car;
import com.example.demo.test.PrintConsumer;
import org.junit.Test;

import java.util.Comparator;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.BiPredicate;
import java.util.function.BinaryOperator;
import java.util.function.BooleanSupplier;
import java.util.function.Consumer;
import java.util.function.DoubleToIntFunction;
import java.util.function.Function;

/** * @author JingQ at 2019/1/25 */
public class JDK8FunctionInterfaceTest {

    /** * BiConsumer<T, U>，接收兩個參數，不返回結果（void） * * 輸出：（說明函數內修改對象引用的話同時會修改對象的值） * 娃哈哈真好喝 * TEST */
    @Test
    public void biConsumerTest() {
        BiConsumer<Car, String> biConsumer = (a, b) -> {
            System.out.println(a.getName() + b);
            a.setName("TEST");
        };
        Car car = new Car();
        car.setName("娃哈哈");
        biConsumer.accept(car, "真好喝");
        System.out.println(car.getName());
    }

    /** * BiFunction<T, U, R>, 接收兩個參數<T, U>，返回R類型的結果 * 輸出: * 0 - 相等 */
    @Test
    public void biFunctionTest() {
        BiFunction<Integer, Integer, String> biFunction = (a, b) -> String.valueOf(a+b);
        System.out.println(biFunction.apply(1, 2).compareTo("3"));
    }

    /** * BinaryOperator<T> 用來接收兩個T類型的參數，返回T類型的結果 */
    @Test
    public void binaryOperatorTest() {
        // 比較二者的最大值
        BinaryOperator<Integer> binaryOperator1 = BinaryOperator.maxBy(Comparator.naturalOrder());
        System.out.println(binaryOperator1.apply(1, 2));

        // 比較二者的最小值
        BinaryOperator<Integer> binaryOperator2 = BinaryOperator.minBy(Comparator.naturalOrder());
        System.out.println(binaryOperator2.apply(3, 4));

        // 相加
        BinaryOperator<Integer> add = (n1, n2) -> n1 + n2;
        System.out.println(add.apply(1, 3));
    }

    /** * BiPredicate<T, U>，接收兩個參數<T, U>，返回一個boolean類型結果 * 輸出： * false */
    @Test
    public void biPredicateTest() {
        BiPredicate<Integer, Integer> biPredicate = (a, b) -> a.equals(b);
        System.out.println(biPredicate.test(1, 3));
    }

    /** * Boolean類型 提供者，用來獲取一個Boolean值 * 若是隻是用來返回true/false，感受這個方法比較雞肋；感受可使用statement，在返回結果前執行 */
    @Test
    public void booleanSupplierTest() {
        BooleanSupplier booleanSupplier = () -> {
            System.out.println("Pre Action");
            return Boolean.TRUE;
        };
        System.out.println(booleanSupplier.getAsBoolean());
    }

    /** * Consumer<T>，接受一個輸入參數，返回空類型void * 還有一個andThen，能夠用來實現責任鏈模式 * * 輸出： * TEST * * NEXT TEST * Pre * End */
    @Test
    public void consumerTest() {
        // 接受String類型的參數
        Consumer<String> consumer = System.out::println;
        consumer.accept("TEST");
        //空格預約
        System.out.println();
        // 責任鏈模式，能夠設定下一個consumer
        // PrintConsumer.java
        // public void accept(String s) {
        // System.out.println("Pre");
        // //xxx
        // System.out.println("End");
        // }
        Consumer<String> nextConsumer = new PrintConsumer();
        consumer.andThen(nextConsumer).accept("NEXT TEST");
    }

    /** * DoubleToIntFunction 只有一個applyAsInt方法，接受double類型的參數，返回int類型的結果 */
    @Test
    public void doubleToIntFunctionTest() {
        DoubleToIntFunction doubleToIntFunction = a -> (int) a;
        System.out.println(doubleToIntFunction.applyAsInt(10L));
    }

    /** * Function<T, U>函數接口，接受T類型的參數，返回U類型的結果 * * compose和andThen這兩個方法的區別在於執行方法的順序問題 * * compose先執行後面函數，而後執行前面的函數；andThen先執行前面的函數，而後再執行後面的函數 */
    @Test
    public void functionTest() {
        // 方法引用，Integer[類名]::valueOf[方法名]（這個是靜態方法引用）
        Function<String, Integer> function1 = Integer::valueOf;
        System.out.println(function1.apply("1010"));
        // 輸出 1010

        // andThen方法的入參類型爲上一個方法的返回類型
        Function<Integer, String> function2 = a -> {
            System.out.println("Pre Action : ");
            return String.valueOf(a) + "10";
        };
        System.out.println(function1.andThen(function2).apply("1010"));
        //輸出
        //Pre Action :
        //101010

        // compose方法
        Function<Integer, String> function3 = a -> {
            System.out.println(a);
            return a + "2020";
        };
        //compose先執行後面函數, 須要注意參數傳遞時調用的方法是否兼容，避免報錯
        System.out.println(function1.compose(function3).apply(10));
        //輸出
        //10
        //102020
    }

}

複製代碼