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(""));