java.util.function包
目錄
Supplier
參數個數擴展
參數類型擴展
特殊變形
Function,r>
參數個數擴展
參數類型擴展
特殊變形
Consumer
參數個數擴展
參數類型擴展
特殊變形
Predicate
參數個數擴展
參數類型擴展
特殊變形
java.util.function包下主要為函數接口，主要包含4類函數接口：
- Supplier<T>: 數據提供器，可以提供 T 類型對象；無參的構造器，提供了 get 方法；
- Function<T,R>: 數據轉換器，接收一個 T 類型的對象，返回一個 R類型的對象； 單參數單返回值的行為接口；提供了 apply, compose, andThen, identity 方法；
- Consumer<T>: 數據消費器， 接收一個 T類型的對象，無返回值，通常用于設置T對象的值； 單參數無返回值的行為接口；提供了 accept, andThen 方法；
- Predicate<T>: 條件測試器，接收一個 T 類型的對象，返回布爾值，通常用于傳遞條件函數； 單參數布爾值的條件性接口。提供了 test (條件測試) , and-or- negate(與或非) 方法。
Consumer與Function都有andThen方法，都返回一個function，但是意義不一樣。
Consumer是在輸入參數上先應用this對象的apply，再應用after的apply。
Function是先應用this對象的apply()方法，產生一個結果，再把此結果作為輸入參數，應用到after的apply()方法。
Consumer：
(T t, U u) -> after.apply(apply(t, u));
Function：
(T t) -> after.apply(apply(t));
?
Supplier<T>
@FunctionalInterface
public interface Supplier<T> {
??? /**
???? * Gets a result.
???? *
???? * @return a result
???? */
??? T get();
}
參數個數擴展
參數類型擴展
BooleanSupplier
public interface BooleanSupplier {
??? boolean getAsBoolean();
}
DoubleSupplier
public interface DoubleSupplier {
??? double getAsDouble();
}
IntSupplier
public interface IntSupplier {
??? int getAsInt();
}
?
LongSupplier
public interface LongSupplier {
??? long getAsLong();
}
?
特殊變形
Function<T,R>
@FunctionalInterface
public interface Function<T, R> {
??? /**
???? * Applies this function to the given argument.
???? */
??? R apply(T t);
??? /**
???? * Returns a composed function that first applies the {@code before}
???? * function to its input, and then applies this function to the result.
???? */
??? default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
??????? Objects.requireNonNull(before);
?????? //before.apply(v)：輸入類型V，返回類型T
????? //最終函數：輸入類型T，返回類型R
??????? return (V v) -> apply(before.apply(v));
??? }
??? /**
???? * Returns a composed function that first applies this function to
???? * its input, and then applies the {@code after} function to the result.
???? */
??? default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
??????? Objects.requireNonNull(after);
?????? //apply(t)：輸入類型T，返回類型R
????? //最終函數：輸入類型R，返回類型V
??????? return (T t) -> after.apply(apply(t));
??? }
??? /**
???? * Returns a function that always returns its input argument.
???? */
??? static <T> Function<T, T> identity() {
??????? return t -> t;
??? }
}
參數個數擴展
BiFunction
public interface BiFunction<T, U, R> {
??? R apply(T t, U u);
???
??? default <V> BiFunction<T, U, V> andThen(Function<? super R, ? extends V> after) {
??????? Objects.requireNonNull(after);
??????? return (T t, U u) -> after.apply(apply(t, u));
??? }
}
?
?
ToDoubleBiFunction
public interface ToDoubleBiFunction<T, U> {
??? double applyAsDouble(T t, U u);
}
?
ToIntBiFunction
public interface ToIntBiFunction<T, U> {
??? int applyAsInt(T t, U u);
}
?
ToLongBiFunction
public interface ToLongBiFunction<T, U> {
??? long applyAsLong(T t, U u);
}
?
參數類型擴展
DoubleFunction
public interface DoubleFunction<R> {
??? R apply(double value);
}
?
DoubleToIntFunction
public interface DoubleToIntFunction {
??? int applyAsInt(double value);
}
?
DoubleToLongFunction
public interface DoubleToLongFunction {
??? long applyAsLong(double value);
}
?
IntFunction
public interface IntFunction<R> {
??? R apply(int value);
}
IntToDoubleFunction
public interface IntToDoubleFunction {
??? double applyAsDouble(int value);
}
?
IntToLongFunction
public interface IntToLongFunction {
??? long applyAsLong(int value);
}
?
LongFunction
public interface LongFunction<R> {
??? R apply(long value);
}
LongToDoubleFunction
public interface LongToDoubleFunction {
??? double applyAsDouble(long value);
}
?
LongToIntFunction
public interface LongToIntFunction {
??? int applyAsInt(long value);
}
?
ToDoubleFunction
public interface ToDoubleFunction<T> {
??? double applyAsDouble(T value);
}
?
ToIntFunction
public interface ToIntFunction<T> {
??? int applyAsInt(T value);
}
ToLongFunction
public interface ToLongFunction<T> {
??? long applyAsLong(T value);
}
?
?
特殊變形
UnaryOperator
public interface UnaryOperator<T> extends Function<T, T> {
//返回值是一個Function
??? static <T> UnaryOperator<T> identity() {
??????? return t -> t;
??? }
}
?
IntUnaryOperator
public interface IntUnaryOperator {
??? int applyAsInt(int operand);
//返回值為一個Function
??? default IntUnaryOperator compose(IntUnaryOperator before) {
??????? Objects.requireNonNull(before);
??????? return (int v) -> applyAsInt(before.applyAsInt(v));
??? }
//返回值為一個Function
??? default IntUnaryOperator andThen(IntUnaryOperator after) {
??????? Objects.requireNonNull(after);
??????? return (int t) -> after.applyAsInt(applyAsInt(t));
??? }
??? static IntUnaryOperator identity() {
??????? return t -> t;
??? }
}
LongUnaryOperator
public interface LongUnaryOperator {
??? long applyAsLong(long operand);
??? default LongUnaryOperator compose(LongUnaryOperator before) {
??????? Objects.requireNonNull(before);
??????? return (long v) -> applyAsLong(before.applyAsLong(v));
??? }
??? default LongUnaryOperator andThen(LongUnaryOperator after) {
??????? Objects.requireNonNull(after);
??????? return (long t) -> after.applyAsLong(applyAsLong(t));
??? }
??? static LongUnaryOperator identity() {
??????? return t -> t;
??? }
}
DoubleUnaryOperator
public interface DoubleUnaryOperator {
??? double applyAsDouble(double operand);
??? default DoubleUnaryOperator compose(DoubleUnaryOperator before) {
??????? Objects.requireNonNull(before);
??????? return (double v) -> applyAsDouble(before.applyAsDouble(v));
??? }
??? default DoubleUnaryOperator andThen(DoubleUnaryOperator after) {
??????? Objects.requireNonNull(after);
??????? return (double t) -> after.applyAsDouble(applyAsDouble(t));
??? }
??? static DoubleUnaryOperator identity() {
??????? return t -> t;
??? }
}
?
BinaryOperator
public interface BinaryOperator<T> extends BiFunction<T,T,T> {
??? public static <T> BinaryOperator<T> minBy(Comparator<? super T> comparator) {
??????? Objects.requireNonNull(comparator);
??????? return (a, b) -> comparator.compare(a, b) <= 0 ? a : b;
??? }
??? public static <T> BinaryOperator<T> maxBy(Comparator<? super T> comparator) {
??????? Objects.requireNonNull(comparator);
??????? return (a, b) -> comparator.compare(a, b) >= 0 ? a : b;
??? }
}
DoubleBinaryOperator
public interface DoubleBinaryOperator {
??? double applyAsDouble(double left, double right);
}
?
IntBinaryOperator
public interface IntBinaryOperator {
??? int applyAsInt(int left, int right);
}
?
LongBinaryOperator
public interface LongBinaryOperator {
??? long applyAsLong(long left, long right);
}
?
?
Consumer<T>
@FunctionalInterface
public interface Consumer<T> {
??? /**
???? * Performs this operation on the given argument.
???? *
???? * @param t the input argument
???? */
??? void accept(T t);
??? /**
???? * Returns a composed {@code Consumer} that performs, in sequence, this
???? * operation followed by the {@code after} operation. If performing either
???? * operation throws an exception, it is relayed to the caller of the
???? * composed operation.? If performing this operation throws an exception,
???? * the {@code after} operation will not be performed.
???? */
??? default Consumer<T> andThen(Consumer<? super T> after) {
??????? Objects.requireNonNull(after);
?????? //accept(t)：輸入類型T，無返回值。
????? //繼續應用after.accept,輸入類型T
??????? return (T t) -> { accept(t); after.accept(t); };
??? }
}
參數個數擴展
參數類型擴展
DoubleConsumer
public interface DoubleConsumer {
??? void accept(double value);
??? default DoubleConsumer andThen(DoubleConsumer after) {
??????? Objects.requireNonNull(after);
??????? return (double t) -> { accept(t); after.accept(t); };
??? }
}
IntConsumer
public interface IntConsumer {
??? void accept(int value);
??? default IntConsumer andThen(IntConsumer after) {
??????? Objects.requireNonNull(after);
??????? return (int t) -> { accept(t); after.accept(t); };
??? }
}
?
LongConsumer
public interface LongConsumer {
??? void accept(long value);
??? default LongConsumer andThen(LongConsumer after) {
??????? Objects.requireNonNull(after);
??????? return (long t) -> { accept(t); after.accept(t); };
??? }
}
ObjDoubleConsumer
public interface ObjDoubleConsumer<T> {
??? void accept(T t, double value);
}
?
ObjIntConsumer
public interface ObjIntConsumer<T> {
??? void accept(T t, int value);
}
?
ObjLongConsumer
public interface ObjLongConsumer<T> {
??? void accept(T t, long value);
}
?
?
特殊變形
Predicate<T>
@FunctionalInterface
public interface Predicate<T> {
??? /**
???? * Evaluates this predicate on the given argument.
???? */
??? boolean test(T t);
??? /**
???? * Returns a composed predicate that represents a short-circuiting logical
???? * AND of this predicate and another.? When evaluating the composed
???? * predicate, if this predicate is {@code false}, then the {@code other}
???? * predicate is not evaluated.
???? */
??? default Predicate<T> and(Predicate<? super T> other) {
??????? Objects.requireNonNull(other);
??????? return (t) -> test(t) && other.test(t);
??? }
??? /**
???? * Returns a predicate that represents the logical negation of this
???? * predicate.
???? */
??? default Predicate<T> negate() {
??????? return (t) -> !test(t);
??? }
??? /**
???? * Returns a composed predicate that represents a short-circuiting logical
???? * OR of this predicate and another.? When evaluating the composed
???? * predicate, if this predicate is {@code true}, then the {@code other}
???? * predicate is not evaluated.
?
???? */
??? default Predicate<T> or(Predicate<? super T> other) {
??????? Objects.requireNonNull(other);
??????? return (t) -> test(t) || other.test(t);
??? }
??? /**
???? * Returns a predicate that tests if two arguments are equal according
???? * to {@link Objects#equals(Object, Object)}.
???? */
??? static <T> Predicate<T> isEqual(Object targetRef) {
??????? return (null == targetRef)
??????????????? ? Objects::isNull
??????????????? : object -> targetRef.equals(object);
??? }
}
?
參數個數擴展
BiPredicate
public interface BiPredicate<T, U> {
??? boolean test(T t, U u);
??
??? default BiPredicate<T, U> and(BiPredicate<? super T, ? super U> other) {
??????? Objects.requireNonNull(other);
??????? return (T t, U u) -> test(t, u) && other.test(t, u);
??? }
???
??? default BiPredicate<T, U> negate() {
??????? return (T t, U u) -> !test(t, u);
??? }
?
??? default BiPredicate<T, U> or(BiPredicate<? super T, ? super U> other) {
??????? Objects.requireNonNull(other);
??????? return (T t, U u) -> test(t, u) || other.test(t, u);
??? }
}
?
參數類型擴展
DoublePredicate
public interface DoublePredicate {
??? boolean test(double value);
??
??? default DoublePredicate and(DoublePredicate other) {
??????? Objects.requireNonNull(other);
??????? return (value) -> test(value) && other.test(value);
??? }
???
??? default DoublePredicate negate() {
??????? return (value) -> !test(value);
??? }
?
??? default DoublePredicate or(DoublePredicate other) {
??????? Objects.requireNonNull(other);
??????? return (value) -> test(value) || other.test(value);
??? }
}
?
?
IntPredicate
public interface IntPredicate {
??
??? boolean test(int value);
??
??? default IntPredicate and(IntPredicate other) {
??????? Objects.requireNonNull(other);
??????? return (value) -> test(value) && other.test(value);
??? }
??? default IntPredicate negate() {
??????? return (value) -> !test(value);
??? }
?
??? default IntPredicate or(IntPredicate other) {
??????? Objects.requireNonNull(other);
??????? return (value) -> test(value) || other.test(value);
??? }
}
?
?
LongPredicate
public interface LongPredicate {
??
??? boolean test(long value);
???
??? default LongPredicate and(LongPredicate other) {
??????? Objects.requireNonNull(other);
??????? return (value) -> test(value) && other.test(value);
??? }
??
??? default LongPredicate negate() {
??????? return (value) -> !test(value);
??? }
???
??? default LongPredicate or(LongPredicate other) {
??????? Objects.requireNonNull(other);
??????? return (value) -> test(value) || other.test(value);
??? }
}
?
特殊變形
?
?
?
總結
以上是生活随笔為你收集整理的java.util.function包的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： Lambda表达式的基础知识
- 下一篇： Java8函数式编程（1）--Princ