Java 8 新特性-Function函数式接口

说明

java.util.function包是Java 8增加的一个新技术点"函数式接口"，此包共有43个接口。这些接口是为了使Lamdba函数表达式使用的更加简便，当然你也可以自己自定义接口来应用于Lambda函数表达式。Lambda是Java 8 的最大特点，本文对此并没有进行详解。本文还应用了Java 8的另一个特点“引用方法”(引用方法是用的冒号“::”来进行方法的调用)，有兴趣的Friends可以去上网查一下。

本文中的接口并非全部我都写了实例，一些数据类型不同但功能相同的接口我只写了一个作为参考。最后，我写的如有不足之处请多指教。

Consumer-消费者

Consumer	提供一个T类型的输入参数，不返回执行结果
BiConsumer	提供两个自定义类型的输入参数，不返回执行结果
DoubleConsumer	表示接受单个double值参数，但不返回结果的操作
IntConsumer	表示接受单个int值参数，但不返回结果的操作
LongConsumer	表示接受单个long值参数，但不返回结果的操作
ObjDoubleConsumer	表示接受object值和double值，但是不返回任何操作结果
ObjIntConsumer	表示接受object值和int值，但是不返回任何操作结果
ObjLongConsumer	表示接受object值和long值，但是不返回任何操作结果

Consumer

提供一个T类型的输入参数，不返回执行结果

void  accept(T t)	对给定的参数执行操作
default  Consumer  andThen(Consumer after)	返回一个组合函数，after将会在该函数执行之后应用

accept(T t)

StringBuilder sb = new StringBuilder("Hello ");
Consumer consumer = (str) -> str.append("Jack!");
consumer.accept(sb);
System.out.println(sb.toString());	// Hello Jack!

andThen(Consumer after)

Consumer consumer1 = (str) -> str.append(" Bob!");
consumer.andThen(consumer1).accept(sb);
System.out.println(sb.toString());	// Hello Jack! Bob!

BiConsumer

提供两个自定义类型的输入参数，不返回执行结果

void  accept(T t, U u)	对给定的参数执行操作
default  BiConsumer  andThen(BiConsumer after)	返回一个组合函数，after将会在该函数执行之后应用

accept(T t, U u)

StringBuilder sb = new StringBuilder();
BiConsumer biConsumer = (a, b) -> {
	sb.append(a);
	sb.append(b);
};
biConsumer.accept("Hello ", "Jack!");
System.out.println(sb.toString());	// Hello Jack!

andThen(BiConsumer after)

BiConsumer biConsumer1 = (a, b) -> {
	System.out.println(a + b);
};
biConsumer.andThen(biConsumer1).accept("Hello", " Jack!"); // Hello Jack!

DoubleConsumer

表示接受单个double值参数，但不返回结果的操作

void  accept(double value)	对给定的参数执行操作
default DoubleConsumer  andThen(DoubleConsumer after)	返回一个组合函数，after在该函数执行之后应用

accept(double value)

DoubleConsumer doubleConsumer = System.out::println;
doubleConsumer.accept(1.3); // 1.3

andThen(DoubleConsumer after)

DoubleConsumer doubleConsumer1 = System.out::println;
doubleConsumer.andThen(doubleConsumer1).accept(1.3); // 1.3  1.3

ObjDoubleConsumer

表示接受object值和double值，但是不返回任何操作结果

void  accept(T t, double value)

对给定的参数执行操作

accept(T t, double value)

ObjDoubleConsumer doubleConsumer = (obj, doub)
	-> System.out.println(obj + doub);
doubleConsumer.accept("金额：", 222.66); // 金额：222.66

Predicate-谓语

Predicate	对给定的输入参数执行操作，返回一个boolean类型的结果（布尔值函数）
BiPredicate	对给定的两个输入参数执行操作，返回一个boolean类型的结果（布尔值函数）
DoublePredicate	对给定的double参数执行操作，返回一个boolean类型的结果（布尔值函数）
IntPredicate	对给定的int输入参数执行操作，返回一个boolean类型的结果（布尔值函数）
LongPredicate	对给定的long参数执行操作，返回一个boolean类型的结果（布尔值函数）

Predicate

对给定的输入参数执行操作，返回一个boolean类型的结果（布尔值函数）

boolean  test(T t)	根据给定的参数进行判断
Predicate  and(Predicate other)	返回一个组合判断，将other以短路并且的方式加入到函数的判断中
Predicate  or(Predicate other)	返回一个组合判断，将other以短路或的方式加入到函数的判断中
Predicate  negate()	将函数的判断取反

test(T t)

Predicate predicate = number -> number != 0;
System.out.println(predicate.test(10));    //true

and(Predicate other)

predicate = predicate.and(number -> number >= 10);
System.out.println(predicate.test(10));    //true

or(Predicate other)

predicate = predicate.or(number -> number != 10);
System.out.println(predicate.test(10));    //true

negate()

predicate = predicate.negate();
System.out.println(predicate.test(10));    //false

BiPredicate

对给定的两个输入参数执行操作，返回一个boolean类型的结果（布尔值函数）

boolean  test(T t, U u)	根据给定的两个输入参数进行判断
BiPredicate  and(BiPredicate other)	返回一个组合判断，将other以短路并且的方式加入到函数的判断中
BiPredicate  or(BiPredicate other)	返回一个组合判断，将other以短路或的方式加入到函数的判断中
BiPredicate  negate()	将函数的判断取反

test(T t, U u)

BiPredicate biPredicate = (a, b) -> a != b;
System.out.println(biPredicate.test(1, 2)); // true

and(BiPredicate other)

biPredicate = biPredicate.and((a, b) -> a.equals(b));
System.out.println(biPredicate.test(1, 2)); // false

or(BiPredicate other)

biPredicate = biPredicate.or((a, b) -> a == b);
System.out.println(biPredicate.test(1, 1)); // true

negate()

biPredicate = biPredicate.negate();
System.out.println(biPredicate.test(1, 2)); // false

DoublePredicate

对给定的double参数执行操作，返回一个boolean类型的结果（布尔值函数）

boolean  test(double value)	根据给定的参数进行判断
DoublePredicate  and(DoublePredicate other)	返回一个组合判断，将other以短路并且的方式加入到函数的判断中
DoublePredicate  or(DoublePredicate other)	返回一个组合判断，将other以短路或的方式加入到函数的判断中
default DoublePredicate negate()	将函数的判断取反

test(double value)

DoublePredicate doublePredicate = doub -> doub != 0;
System.out.println(doublePredicate.test(10)); // true

and(DoublePredicate other)

doublePredicate = doublePredicate.and(doub -> doub < 2);
System.out.println(doublePredicate.test(1.7)); // true

or(DoublePredicate other)

doublePredicate = doublePredicate.or(doub -> doub > 2);
System.out.println(doublePredicate.test(1.7)); // true

negate()

doublePredicate = doublePredicate.negate();
System.out.println(doublePredicate.test(1.7)); // false

Function-功能

Function	接收一个参数并返回结果的函数
BiFunction	接受两个参数并返回结果的函数
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	接收两个参数并返回double结果的函数
ToDoubleFunction	接收一个参数并返回double结果的函数
ToIntBiFunction	接收两个参数并返回int结果的函数
ToIntFunction	接收一个参数并返回int结果的函数
ToLongBiFunction	接收两个参数并返回long结果的函数
ToLongFunction	接收一个参数并返回long结果的函数

Function

接收一个参数并返回结果的函数

R  apply(T t)	将此参数应用到函数中
Function  andThen(Function after)	返回一个组合函数，该函数结果应用到after函数中
Function  compose(Function before)	返回一个组合函数，首先将入参应用到before函数，再将before函数结果应用到该函数中

apply(T t)

Function function = a -> a + " Jack!";
System.out.println(function.apply("Hello")); // Hello Jack!

andThen(Function after)

Function function = a -> a + " Jack!";
Function function1 = a -> a + " Bob!";
String greet = function.andThen(function1).apply("Hello");
System.out.println(greet); // Hello Jack! Bob!

compose(Function before)

Function function = a -> a + " Jack!";
Function function1 = a -> a + " Bob!";
String greet = function.compose(function1).apply("Hello");
System.out.println(greet); // Hello Bob! Jack!

BiFunction

接受两个参数并返回结果的函数

R apply(T t, U u)	将参数应用于函数执行
BiFunction andThen(Function after)	返回一个组合函数，after函数应用于该函数之后

apply(T t, U u)

BiFunction biFunction = (a, b) -> a + b;
System.out.println(biFunction.apply("Hello ", "Jack!")); // Hello Jack!

andThen(Function after)

Function function = (a) -> a + "!!!";
System.out.println(biFunction.andThen(function).apply("Hello", " Jack")); // Hello Jack!!!

DoubleFunction

接收一个double类型的参数并返回结果的函数

R apply(double value)

根据给定参数执行函数

apply(double value)

DoubleFunction doubleFunction = doub -> "结果：" + doub;
System.out.println(doubleFunction.apply(1.6)); // 结果：1.6

DoubleToIntFunction

接收一个double类型的参数并返回int结果的函数

int applyAsInt(double value)

根据给定的参数执行函数

applyAsInt(double value)

DoubleToIntFunction doubleToIntFunction = doub -> Double.valueOf(doub).intValue();
System.out.println(doubleToIntFunction.applyAsInt(1.2)); // 1

ToDoubleBiFunction

接收两个参数并返回double结果的函数

double applyAsDouble(T t, U u)

根据给定的参数执行函数

applyAsDouble(T t, U u)

ToDoubleBiFunction toDoubleBiFunction = (lon, floa) -> lon
	.doubleValue() + floa.doubleValue();
System.out.println(toDoubleBiFunction.applyAsDouble(11L, 235.5f)); // 246.5

ToDoubleFunction

接收一个参数并返回double结果的函数

double applyAsDouble(T value)

根据给定参数执行函数

applyAsDouble(T value)

ToDoubleFunction toDoubleFunction = floa -> floa.doubleValue();
System.out.println(toDoubleFunction.applyAsDouble(12315f)); // 12315.0

Supplier-供应商

Supplier	不提供输入参数，但是返回结果的函数
BooleanSupplier	不提供输入参数，但是返回boolean结果的函数
DoubleSupplier	不提供输入参数，但是返回double结果的函数
IntSupplier	不提供输入参数，但是返回int结果的函数
LongSupplier	不提供输入参数，但是返回long结果的函数

Supplier

无需提供输入参数，返回一个T类型的执行结果

T  get()

获取结果值

get()

Supplier supplier = () -> "Hello Jack!";
System.out.println(supplier.get()); // Hello Jack!

BooleanSupplier

不提供输入参数，但是返回boolean结果的函数

boolean getAsBoolean()

获取函数的执行结果

getAsBoolean()

BooleanSupplier booleanSupplier = () -> true;
System.out.println(booleanSupplier.getAsBoolean()); // true

DoubleSupplier

不提供输入参数，但是返回double结果的函数

double getAsDouble()

获取函数的执行结果

getAsDouble()

DoubleSupplier doubleSupplier = () -> 2.7;
System.out.println(doubleSupplier.getAsDouble()); // 2.7

Operator-操作员

UnaryOperator	提供单个参数，并且返回一个与输入参数类型一致的结果
BinaryOperator	提供两个参数，并且返回结果与输入参数类型一致的结果
DoubleBinaryOperator	提供两个double参数并且返回double结果
DoubleUnaryOperator	提供单个double参数并且返回double结果
IntBinaryOperator	提供两个int参数并且返回int结果
IntUnaryOperator	提供单个int参数并且返回int结果
LongBinaryOperator	提供两个long参数并且返回long结果
LongUnaryOperator	提供单个long参数并且返回long结果

UnaryOperator

对输入参数执行操作，并且输入参数与返回参数类型相同

T apply(T t)	将给定参数应用到函数中
Function  andThen(Function after)	返回一个组合函数，该函数结果应用到after函数中
Function  compose(Function before)	返回一个组合函数，首先将入参应用到before函数，再将before函数结果应用到该函数中

apply(T t)

UnaryOperator unaryOperator = greet -> greet + " Bob!";
System.out.println(unaryOperator.apply("Hello")); // Hello Jack!

andThen(Function after)

UnaryOperator unaryOperator1 = greet -> greet + " Jack!";
String greet = unaryOperator.andThen(unaryOperator1).apply("Hello");
System.out.println(greet); // Hello Bob! Jack!

compose(Function before)

String greet = unaryOperator.compose(unaryOperator1).apply("Hello");
System.out.println(greet); // Hello Jack! Bob!

BinaryOperator

提供两个参数，并且返回结果与输入参数类型一致的结果

R apply(T t, U u)	根据给定参数执行函数
BiFunction andThen(Function after)	返回一个组合函数，after应用于该函数之后

apply(T t, U u)

BinaryOperator binaryOperator = (flag, flag1) -> flag + flag1;
System.out.println(binaryOperator.apply("Hello ", "Jack!")); // Hello Jack!

andThen(Function after)

Function function = a -> a + "!!!";
System.out.println(binaryOperator.andThen(function).apply("Hello", " Jack")); // Hello Jack!!!

DoubleBinaryOperator

提供两个double参数并且返回double结果

double applyAsDouble(double left, double right)

根据给定的参数执行函数

applyAsDouble(double left, double right)

DoubleBinaryOperator doubleBinaryOperator = (doub1, doub2) -> doub1
	+ doub2;
System.out.println(doubleBinaryOperator.applyAsDouble(1.1, 2.3)); // 3.4

DoubleUnaryOperator

提供单个double参数并且返回double结果

double applyAsDouble(double operand)	根据给定参数执行函数
DoubleUnaryOperator andThen(DoubleUnaryOperator after)	返回一个组合函数，after应用于该函数之后
DoubleUnaryOperator compose(DoubleUnaryOperator before)	返回一个组合函数，before应用于该函数之前

applyAsDouble(double operand)

DoubleUnaryOperator doubleUnaryOperator = doub -> doub + 2.5;
System.out.println(doubleUnaryOperator.applyAsDouble(2.6)); // 5.1

andThen(DoubleUnaryOperator after)

DoubleUnaryOperator doubleUnaryOperator1 = doub -> doub * 3;
double result = doubleUnaryOperator.andThen(doubleUnaryOperator1)
	.applyAsDouble(10); 
System.out.println(result); // (10 + 2.5) * 3 = 37.5

compose(DoubleUnaryOperator before)

double result = doubleUnaryOperator.compose(doubleUnaryOperator1)
	.applyAsDouble(10);
System.out.println(result); // 10 * 3 + 2.5 = 32.5