Java8
为函数式接口引入了一个新注解@FunctionalInterface
,主要用于编译级错误检查,加上该注解,当接口不符合函数式接口定义的时候,编译器会报错。@FunctionalInterface
对于接口是不是函数式接口没有影响,该注解只是提醒编译器去检查该接口是否仅包含一个抽象方法。。函数式接口Functional Interface
就是一个有且仅有一个抽象方法,但是可以有多个非抽象方法的接口。
@FunctionalInterface
public interface SoaFunction<T, K> {
K doRequest(T request) throws Exception;
}
简单总结
接口 | 描述 | 概述 |
---|---|---|
Function<T,R> | 接收一个参数并返回结果的函数 | 有参有返 |
Consumer |
提供一个T类型的输入参数,不返回执行结果 | 有参无返 |
Supplier |
不提供输入参数,但是返回结果的函数 | 无参有返 |
Predicate |
对给定的输入参数执行操作,返回一个boolean类型的结果(布尔值函数) | 有参返boolean |
UnaryOperator |
提供单个类型参数,并且返回一个与输入参数类型一致的结果 | 有参有返 |
对于Stream
流大家常用的方法中集合个所有的Function类型,下面逐个介绍
filter(Predicate<? super T> predicate)
条件筛选
map(Function<? super T, ? extends R> mapper)
对单个item
对象转换操作
flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)
对item
对象操作,并返回一个新的Stream
流
forEach(Consumer<? super T> action)
循环遍历
anyMatch(Predicate<? super T> predicate
) 条件筛选,整个集合item
有一个为true
allMatch(Predicate<? super T> predicate)
条件筛选,全部item
为true
reduce(BinaryOperator<T> accumulator)
累计计算,值累加等
collect(Collector<? super T, A, R> collector)
集合操作,元素汇总转换计算
一、Function 函数
接口 | 描述 |
---|---|
Function<T,R> | 接收一个参数并返回结果的函数 |
BiFunction<T,U,R> | 接受两个参数并返回结果的函数 |
DoubleFunction |
接收一个double类型的参数并返回结果的函数 |
DoubleToIntFunction | 接收一个double类型的参数并返回int结果的函数 |
DoubleToLongFunction | 接收一个double类型的参数并返回long结果的函数 |
IntFunction |
接收一个int类型的参数并返回结果的函数 |
IntToDoubleFunction | 接收一个int类型的参数并返回double结果的函数 |
IntToLongFunction | 接收一个int类型的参数并返回long结果的函数 |
LongFunction |
接收一个long类型的参数并返回结果的函数 |
LongToDoubleFunction | 接收一个long类型的参数并返回double结果的函数 |
LongToIntFunction | 接收一个long类型的参数并返回int结果的函数 |
ToDoubleBiFunction<T,U> | 接收两个参数并返回double结果的函数 |
ToDoubleFunction |
接收一个参数并返回double结果的函数 |
ToIntBiFunction<T,U> | 接收两个参数并返回int结果的函数 |
ToIntFunction |
接收一个参数并返回int结果的函数 |
ToLongBiFunction<T,U> | 接收两个参数并返回long结果的函数 |
ToLongFunction |
接收一个参数并返回long结果的函数 |
Function
接口方法:
【1】R apply(T t)
将此参数应用到函数中
Function<String, String> function = a -> a +" hello world!";
System.out.println(function.apply("English")); // English hello world!
【2】Function<T, R> andThen(Function<? super R,? extends V> after)
返回一个组合函数,该函数结果应用到after函数中
Function<String, String> oneFunction = a -> a +" Java!";
Function<String, String> twoFunction = a -> a + " C!";
String greet = oneFunction.andThen(twoFunction).apply("Hello");
System.out.println(greet); // Hello Java! C!
【3】Function<T, R> compose(Function<? super V,? extends T> before)
返回一个组合函数,首先将入参应用到before
函数,再将before
函数结果应用到该函数中
Function<String, String> oneFunction = a -> a +" Java!";
Function<String, String> twoFunction = a -> a + " C!";
String greet = oneFunction.compose(twoFunction).apply("Hello");
System.out.println(greet); // Hello C! Java!
BiFunction<T, U, R>
接口方法:
【1】R apply(T t)
将此参数应用到函数中
BiFunction<String, String, String> biFunction = (a, b) -> a + b;
System.out.println(biFunction.apply("Hello ", "Java!")); // Hello Java!
【2】BiFunction<T,U,V> andThen(Function<? super R,? extends V> after)
返回一个组合函数,after
函数应用于该函数之后
BiFunction<String, String, String> biFunction = (a, b) -> a + b;
Function<String, String> function = (a) -> a +" out";
System.out.println(biFunction.andThen(function).apply("Hello", " Java")); // Hello Java out
DoubleFunction
接口方法:R apply(double value)
根据给定参数执行函数
DoubleFunction<String> doubleFunction = doub ->"结果:" + doub;
System.out.println(doubleFunction.apply(666.6)); // 结果:666.6
ToDoubleFunction
接口方法:double applyAsDouble(T value)
根据给定参数执行函数
ToDoubleFunction<Float> toDoubleFunction = floa -> floa.doubleValue();
System.out.println(toDoubleFunction.applyAsDouble(111f)); // 111.0
DoubleToIntFunction
接口方法:int applyAsInt(double value)
根据给定的参数执行函数
DoubleToIntFunction doubleToIntFunction = doub -> Double.valueOf(doub).intValue();
System.out.println(doubleToIntFunction.applyAsInt(1.1)); // 1
ToDoubleBiFunction<T,U>
接口方法:double applyAsDouble(T t, U u)
根据给定的参数执行函数
ToDoubleBiFunction<Long, Float> toDoubleBiFunction = (lon, floa) -> lon.doubleValue() + floa.doubleValue();
System.out.println(toDoubleBiFunction.applyAsDouble(11L, 22.2f)); // 33.2
二、Consumer
消费者
接口 | 描述 |
---|---|
Consumer |
提供一个T类型的输入参数,不返回执行结果 |
BiConsumer<T,U> | 提供两个自定义类型的输入参数,不返回执行结果 |
DoubleConsumer | 表示接受单个double值参数,但不返回结果的操作 |
IntConsumer | 表示接受单个int值参数,但不返回结果的操作 |
LongConsumer | 表示接受单个long值参数,但不返回结果的操作 |
ObjDoubleConsumer |
表示接受object值和double值,但是不返回任何操作结果 |
ObjIntConsumer |
表示接受object值和int值,但是不返回任何操作结果 |
ObjLongConsumer |
表示接受object值和long值,但是不返回任何操作结果 |
Consumer<T>
接口方法:
【1】void accept(T t)
对给定的参数执行操作
StringBuilder sb = new StringBuilder("Hello ");
Consumer<StringBuilder> consumer = (str) -> str.append("Java!");
consumer.accept(sb);
System.out.println(sb.toString()); // Hello Java!
【2】default Consumer andThen(Consumer<? super T> after)
返回一个组合函数,after
将会在该函数执行之后应用
StringBuilder sb = new StringBuilder("Hello ");
Consumer<StringBuilder> consumer = (str) -> str.append("Java!");
Consumer<StringBuilder> consumer1 = (str) -> str.append(" C!");
consumer.andThen(consumer1).accept(sb);
System.out.println(sb.toString()); // Hello Java! C!
BiConsumer<T,U>
接口方法:
【1】void accept(T t, U u)
对给定的参数执行操作
StringBuilder sb = new StringBuilder();
BiConsumer<String, String> biConsumer = (a, b) -> {
sb.append(a);
sb.append(b);
};
biConsumer.accept("Hello ", "Java!");
System.out.println(sb.toString()); // Hello Java!
【2】default BiConsumer<T,U> andThen(BiConsumer<? super T,? super U> after)
返回一个组合函数,after
将会在该函数执行之后应用
StringBuilder sb = new StringBuilder();
BiConsumer<String, String> biConsumer = (a, b) -> {
sb.append(a);
sb.append(b);
};
BiConsumer<String, String> biConsumer1 = (a, b) -> {
sb.append(a);
sb.append(b);
};
biConsumer.andThen(biConsumer1).accept("Hello", " Java! ");
System.out.println(sb.toString()); // Hello Java! Hello Java!
DoubleConsumer
接口方法:
【1】void accept(double value)
对给定的参数执行操作
DoubleConsumer doubleConsumer = System.out::println;
doubleConsumer.accept(1.3); // 1.3
【2】default DoubleConsumer andThen(DoubleConsumer after)
返回一个组合函数,after
在该函数执行之后应用
DoubleConsumer doubleConsumer = System.out::println;
DoubleConsumer doubleConsumer1 = System.out::println;
doubleConsumer.andThen(doubleConsumer1).accept(1.3);
// 1.3
// 1.3
ObjDoubleConsumer<T>
接口方法:void accept(T t, double value)
对给定的参数执行操作
ObjDoubleConsumer<String> doubleConsumer = (obj, doub) -> System.out.println(obj + doub);
doubleConsumer.accept("金额:", 222.22); // 金额:222.22
三、Supplier
供应商
接口 | 描述 |
---|---|
Supplier |
不提供输入参数,但是返回结果的函数 |
BooleanSupplier | 不提供输入参数,但是返回boolean结果的函数 |
DoubleSupplier | 不提供输入参数,但是返回double结果的函数 |
IntSupplier | 不提供输入参数,但是返回int结果的函数 |
LongSupplier | 不提供输入参数,但是返回long结果的函数 |
Supplier<T>
接口方法:T get()
获取结果值
Supplier<String> supplier = () ->"Hello Java!";
System.out.println(supplier.get()); // Hello Java!
BooleanSupplier
接口方法:boolean getAsBoolean()
获取函数的执行结果
BooleanSupplier booleanSupplier = () -> 1 == 1;
System.out.println(booleanSupplier.getAsBoolean()); // true
DoubleSupplier
接口方法:double getAsDouble()
获取函数的执行结果
DoubleSupplier doubleSupplier = () -> 2.7;
System.out.println(doubleSupplier.getAsDouble()); // 2.7
四、Predicate
谓语
接口 | 描述 |
---|---|
Predicate |
对给定的输入参数执行操作,返回一个boolean类型的结果(布尔值函数) |
BiPredicate<T,U> | 对给定的两个输入参数执行操作,返回一个boolean类型的结果(布尔值函数) |
DoublePredicate | 对给定的double参数执行操作,返回一个boolean类型的结果(布尔值函数) |
IntPredicate | 对给定的int输入参数执行操作,返回一个boolean类型的结果(布尔值函数) |
LongPredicate | 对给定的long参数执行操作,返回一个boolean类型的结果(布尔值函数) |
Predicate<T>
接口方法:
【1】boolean test(T t)
根据给定的参数进行判断
Predicate<Integer> predicate = number -> number == 0;
System.out.println(predicate.test(0)); //true
【2】Predicate and(Predicate<? super T> other)
返回一个组合判断,将other
以短路与的方式加入到函数的判断中
Predicate<Integer> predicate = number -> number !=0;
predicate = predicate.and(number -> number >= 10);
System.out.println(predicate.test(10)); //true
【3】Predicate or(Predicate<? super T> other)
返回一个组合判断,将other
以短路或的方式加入到函数的判断中
Predicate<Integer> predicate = number -> number !=0;
predicate = predicate.or(number -> number != 10);
System.out.println(predicate.test(10)); //true
【4】Predicate negate()
将函数的判断取反
Predicate<Integer> predicate = number -> number !=0;
predicate = predicate.negate();
System.out.println(predicate.test(10)); //false
BiPredicate<T,U>
接口方法:
【1】boolean test(T t, U u)
根据给定的两个输入参数进行判断
BiPredicate<Integer, Integer> biPredicate = (a, b) -> a != b;
System.out.println(biPredicate.test(1, 2)); // true
【2】BiPredicate<T,U> and(BiPredicate<? super T,? super U> other)
返回一个组合判断,将other
以短路与的方式加入到函数的判断中
BiPredicate<Integer, Integer> biPredicate = (a, b) -> a != b;
biPredicate = biPredicate.and((a, b) -> a.equals(b));
System.out.println(biPredicate.test(1, 2)); // false
【3】BiPredicate<T,U> or(BiPredicate<? super T,? super U> other)
返回一个组合判断,将other
以短路或的方式加入到函数的判断中
BiPredicate<Integer, Integer> biPredicate = (a, b) -> a != b;
biPredicate = biPredicate.or((a, b) -> a == b);
System.out.println(biPredicate.test(1, 1)); // true
【4】BiPredicate<T,U> negate()
将函数的判断取反
BiPredicate<Integer, Integer> biPredicate = (a, b) -> a != b;
biPredicate = biPredicate.negate();
System.out.println(biPredicate.test(1, 2)); // false
五、Operator
操作员
除了Function
,Consumer
,Predicate
,Supplier
这几个基本的函数形式,还有其它派生的函数形式,它们扩展了基本的函数形式,包括UnaryOperator (extends Function)
和BinaryOperator (extends BiFunction)
。
接口 | 描述 |
---|---|
UnaryOperator |
提供单个类型参数,并且返回一个与输入参数类型一致的结果 |
BinaryOperator |
提供两个相同类型参数,并且返回结果与输入参数类型一致的结果 |
DoubleBinaryOperator | 提供两个double参数并且返回double结果 |
DoubleUnaryOperator | 提供单个double参数并且返回double结果 |
IntBinaryOperator | 提供两个int参数并且返回int结果 |
IntUnaryOperator | 提供单个int参数并且返回int结果 |
LongBinaryOperator | 提供两个long参数并且返回long结果 |
LongUnaryOperator | 提供单个long参数并且返回long结果 |
UnaryOperator<T>
接口方法:
【1】T apply(T t)
将给定参数应用到函数中
UnaryOperator<String> unaryOperator = greet -> greet +" Java!";
System.out.println(unaryOperator.apply("Hello")); // Hello Java!
【2】Function<T, R> andThen(Function<? super R,? extends V> after)
返回一个组合函数,该函数结果应用到after函数中
UnaryOperator<String> unaryOperator = greet -> greet +" Java!";
UnaryOperator<String> unaryOperator1 = greet -> greet + " C!";
String greet = unaryOperator.andThen(unaryOperator1).apply("Hello");
System.out.println(greet); // Hello Java! C!
【3】Function<T, R> compose(Function<? super V,? extends T> before)
返回一个组合函数,首先将入参应用到before
函数,再将before
函数结果应用到该函数中
UnaryOperator<String> unaryOperator = greet -> greet +" Java!";
UnaryOperator<String> unaryOperator1 = greet -> greet + " C!";
String greet = unaryOperator.compose(unaryOperator1).apply("Hello");
System.out.println(greet); // Hello C! Java!
BinaryOperator<T>
接口方法:
【1】T apply(T t, T u)
根据给定参数执行函数
BinaryOperator<String> binaryOperator = (flag, flag1) -> flag + flag1;
System.out.println(binaryOperator.apply("Hello ", "Java!")); // Hello Java!
【2】BiFunction<T,T,T> andThen(Function<? super T,? extends T> after)
返回一个组合函数,after应用于该函数之后
BinaryOperator<String> binaryOperator = (flag, flag1) -> flag + flag1;
Function<String, String> function = a -> a +"!!!";
System.out.println(binaryOperator.andThen(function).apply("Hello", " Java")); // Hello Java!!!
【3】BinaryOperator maxBy(Comparator<? super T> comparator)
返回二元操作本身,通过特殊比较器返回最大的元素
BinaryOperator<Integer> integerBinaryOperator = BinaryOperator.maxBy(Integer::compareTo);
Integer max = integerBinaryOperator.apply(12, 10);
System.out.println(max); // 12
【4】BinaryOperator minBy(Comparator<? super T> comparator)
返回二元操作本身,通过特殊比较器返回最小的元素
BinaryOperator<Integer> integerBinaryOperator1 = BinaryOperator.minBy(Integer::compare);
Integer min = integerBinaryOperator1.apply(12, 10);
System.out.println(min); // 10
DoubleBinaryOperator
接口方法:double applyAsDouble(double left, double right)
根据给定的参数执行函数
DoubleBinaryOperator doubleBinaryOperator = (doub1, doub2) -> doub1 + doub2;
System.out.println(doubleBinaryOperator.applyAsDouble(1.1, 2.3)); // 3.4
DoubleUnaryOperator
接口方法:
【1】double applyAsDouble(double operand)
根据给定参数执行函数
DoubleUnaryOperator doubleUnaryOperator = doub -> doub + 2.5;
System.out.println(doubleUnaryOperator.applyAsDouble(2.6)); // 5.1
【2】andThen(DoubleUnaryOperator after)
返回一个组合函数,after
应用于该函数之后
DoubleUnaryOperator doubleUnaryOperator = doub -> doub + 2.5;
DoubleUnaryOperator doubleUnaryOperator1 = doub -> doub * 3;
double result = doubleUnaryOperator.andThen(doubleUnaryOperator1)
.applyAsDouble(10);
System.out.println(result); // (10 + 2.5) * 3 = 37.5
【3】DoubleUnaryOperator compose(DoubleUnaryOperator before)
返回一个组合函数,before
应用于该函数之前
DoubleUnaryOperator doubleUnaryOperator = doub -> doub + 2.5;
DoubleUnaryOperator doubleUnaryOperator1 = doub -> doub * 3;
double result = doubleUnaryOperator.compose(doubleUnaryOperator1)
.applyAsDouble(10);
System.out.println(result); // 10 * 3 + 2.5 = 32.5