JDK8常见函数式接口
Posted 逆行的碎石机
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了JDK8常见函数式接口相关的知识，希望对你有一定的参考价值。
JDK8-2 常见函数式接口
JDK 提供的常见函数式接口
-
Function
接受一个参数，产生一个返回值（代表一个函数）
@FunctionalInterface
public interface Function<T, R> {
//函数式方法
R apply(T t);
// 组合函数，针对输入参数首先应用before函数，然后应用当前函数，如果对任一函数求值时抛出异常，异常会被传递到调用者
default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
Objects.requireNonNull(before);
return (V v) -> apply(before.apply(v));
}
// 组合函数，针对输入参数首先应用当前函数，然后应用after函数
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
}
// 静态方法，返回一个返回值是输入参数的Function
static <T> Function<T, T> identity() {
return t -> t;
}
}
ex: 生成一个 Funcation 实例
// 匿名函数
Function<String,String> function0 = new Function<String, String>() {
@Override
public String apply(String s) {
return s+",";
}
};
// lambda
Function<String,String> function1 = (String a) -> a;
Function<String, String> function2 = Function.identity();
// 方法引用
Function<String,String> function3 = String::valueOf;
// 构造方法引用
Function<String,String> function4 = String::new;
//调用：
function0.apply("abc")
//结果
abc,
-
Supplier
不接受参数，返回一个结果（代表一个供给者）
@FunctionalInterface
public interface Supplier<T> {
// 函数式方法
T get();
}
ex:
// lambda
Supplier<String> supplier0 =() -> String.valueOf("a");
//调用
String s = supplier0.get();
// 结果
a
-
Consumer
接受一个参数，不返回结果（代表一个消费者）
期待通过方法副作用操作输入参数
@FunctionalInterface
public interface Consumer<T> {
// 函数式方法
void accept(T t);
// 代表一个组合函数，先执行当前函数，再执行after函数，如果执行当前函数抛出异常，不会执行after函数，如果执行after函数抛出异常，则异常会传递给调用者
default Consumer<T> andThen(Consumer<? super T> after) {
Objects.requireNonNull(after);
return (T t) -> { accept(t); after.accept(t); };
}
}
ex:
Consumer<String> consumer0 = s->{};
// 调用
consumer0.accept("s");
-
Predicate
接受一个参数，返回一个boolean值（谓词，代表判断）
@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);
}
// 通过Objects的equals判断两个对象是否equals
static <T> Predicate<T> isEqual(Object targetRef) {
return (null == targetRef)
? Objects::isNull
: object -> targetRef.equals(object);
}
}
ex:
Predicate<Object> a = Predicate.isEqual("a");
//调用
boolean a1 = a.test("b");
//结果
false
除了以上函数式接口外，JDK 还提供了 Bi 函数式接口,用于对前面四种的一个扩展，另外为了避免额外的拆装箱性能损耗和使用便捷性，还提供了几种基本数据类型对应的函数式接口。其中有两个是值得注意的：
-
UnaryOperator
代表一元运算，可以看到这是一个Function的子接口，不同之处在于输入类型和返回值类型相同
@FunctionalInterface
public interface UnaryOperator<T> extends Function<T, T> {
static <T> UnaryOperator<T> identity() {
return t -> t;
}
}
ex：
UnaryOperator<Integer> unaryOperator = a -> a=a+5;
Integer apply = unaryOperator.apply(1);
这儿代表的一元运算就是 a=a+5，调用时，针对输入的Integer值复制给a，执行+5的一元运算
-
BinaryOperator
代表二元运算，是BiFunction的子接口，两个输入类型和输出类型一致
@FunctionalInterface
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;
}
}
ex:
BinaryOperator<Integer> binaryOperator = (a, b) -> a + b;
Integer apply = binaryOperator.apply(1, 2);
这儿代表的二元运算是 a+b ,针对输入的Integer执行求和运算
看完三件事
如果你觉得这篇内容对你还蛮有帮助，我想邀请你帮我三个小忙
：
点赞，转发，你们的 『点赞和转发』，才是我创造的动力。
同时可以期待后续文章ing
以上是关于JDK8常见函数式接口的主要内容，如果未能解决你的问题，请参考以下文章