java.util.function包的使用

Consumer

Consumer是一個函數式接口,表示接受一個參數,沒有返回結果。

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);

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

下面就是accept方法的使用,理解爲這就是一個函數, 函數的入參必須要有一個,返回爲void就行,最後那種寫法就是因爲println的入參只有一個String類型的所以才滿足。

Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        consumer.accept("hello");

        consumer = x ->{
            System.out.println(x);
        };

        consumer.accept("hello");

        consumer = System.out::println;

        consumer.accept("hello");

還一個andThen方法,就是consumer1調用andThen方法,參數是consumer2,返回是一個consumer。然後這個consumer再執行accept()就相當於先執行consumer1中的accept()再執行consumer2中的accept()。感覺用到的機會很少,我直接一個consumer能搞定的事爲什麼要用倆。

 

Consumer<String> consumer1 = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println("consumer1" + s );
            }
        };

        Consumer<String> consumer2 = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println("consumer2" + s);
            }
        };

        consumer1.andThen(consumer2).accept("hello");

Supplier

很簡單,只有一個get()方法

@FunctionalInterface
public interface Supplier<T> {

    T get();
}

 

Supplier<String> supplier = ()->{
            System.out.println("hello");
            return "";
        };

        supplier.get();

那這個Supplier在實際中有哪些使用場景呢?

我們通過client調用server端服務,可能因爲網絡等原因造成調用失敗,這時候我們需要在調用失敗的時候進行重試。

這時候supplier使用起來就顯得比較優雅

private  static  int num = 5;

    public static void main(String[] args) {
        Supplier<String> supplier = ()->{
            System.out.println("hello");
            System.out.println(1/0);
            return "hello";
        };

        retry(supplier,1);
    }

    public static  <T> T retry(Supplier<T> supplier,int count){
        try{
            return supplier.get();
        }catch (Exception e){
            if(count < num){
                return  retry(supplier,++count);
            }else {
                throw new RuntimeException("----------");
            }
        }
    }

 Function

R apply(T t)接受參數T,返回類型爲R

@FunctionalInterface
public interface Function<T, R> {

    R apply(T t);

    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

    
    static <T> Function<T, T> identity() {
        return t -> t;
    }
}
Function<String,Integer> function = o ->{
            System.out.println("hello");
            return 123;
        } ;
        System.out.println(function.apply(""));

 當傳入參數和返回類型一樣的時候可以用下面這種

@FunctionalInterface
public interface UnaryOperator<T> extends Function<T, T>

Predicate

@FunctionalInterface
public interface Predicate<T> {

    
    boolean test(T t);

    
    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }

   
    default Predicate<T> negate() {
        return (t) -> !test(t);
    }

   
    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

    
    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

 一個傳入參數,返回類型boolean

Predicate<String> predicate = o->{
            return false;
        };

        System.out.println(predicate.test(""));

 

發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章