java8 新特性之函數式接口Function、Consumer、Supplier、Predicate

java8引入了四大函數式接口：Function、Consumer、Supplier、Predicate；這幾個接口在Optional類中有大量應用，之前我們剛好學習了Optional的用法 https://www.jianshu.com/p/3b23034416f9。這次在這裏可以舉一反三了。

Function<T, R>

Function<T, R> T：入參類型，R：出參類型

    public static void main(String[] args) {
        // 定義Function
        Function<Integer, Integer> func = p -> p * 10;
        //調用
        Integer apply = func.apply(11);
        System.out.println(apply);
    }

Optional類中有:Optional.map()、Optional.flatMap()

    public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {
        Objects.requireNonNull(mapper);
        if (!isPresent())
            return empty();
        else {
            return Optional.ofNullable(mapper.apply(value));
        }
    }

Consumer<T>

因爲沒有出參，常用於打印、發送短信等消費動作

Consumer<T> T：入參類型；沒有出參

  public static void main(String[] args) {
        // 定義Consumer
        Consumer<String> consumer= p -> System.out.println(p);
        //調用
        consumer.accept("18800008888");
    }

Optional類中有: Optional.Consumer()

    public void ifPresent(Consumer<? super T> consumer) {
        if (value != null)
            consumer.accept(value);
    }

Supplier<T>

常用於業務“有條件運行”時，符合條件再調用獲取結果的應用場景；運行結果須提前定義，但不運行。

Supplier<T> T：出參類型；沒有入參

    public static void main(String[] args) {
       //定義
        Supplier<Integer> supplier= () -> 100;
        //調用
        Integer integer = supplier.get();
        System.out.println(integer);
    }

Optional類中有:Optional.orElseGet() 和 Optional.orElseThrow()

    public T orElseGet(Supplier<? extends T> other) {
        return value != null ? value : other.get();
    }
    public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
        if (value != null) {
            return value;
        } else {
            throw exceptionSupplier.get();
        }
    }

orElseGet、orElseThrow 中表達式運行的條件是：如果前面用了map(m->m.get(xx))，那麼就是m.get(xx)爲空時；如果前面用的filter(xxx) 那麼就是xxx表達式返回false時。

Predicate<T>

Predicate<T> T：入參類型；出參類型是Boolean

    public static void main(String[] args) {
        //定義Predicate
        Predicate<Integer> predicate = p -> p % 2 == 0;
        //調用
        predicate.test(100);
    }

Optional類中有:Optional.filter()

    public Optional<T> filter(Predicate<? super T> predicate) {
        Objects.requireNonNull(predicate);
        if (!isPresent())
            return this;
        else
            return predicate.test(value) ? this : empty();
    }