Java8的一些新特性 java.util.function包

函数式接口标注 @FunctionalInterface，这样的接口只能有一个抽象方法。


java.util.function包下面有大量的函数式接口，主要分为以下几个基本类别
Function  输入参数为类型T， 输出为类型R， 记作 T -> R
Consumer  输入参数为类型T， 输出为void， 记作 T -> void
Supplier  没有输入参数， 输出为类型T， 记作 void -> T
Predicate 输入参数为类型T， 输出为类型boolean， 记作 T -> boolean


例如计算字符串长度的Function例子

public class MyFunction implements Function<String, Integer> {
	@Override
	public Integer apply(String s) {
		return s.length();
	}
}

再例如，判断字符串是否为空的Predicate

public class StringIsEmptyPredict implements Predicate<String> {
	@Override
	public boolean test(String s) {
		return s == null || s.isEmpty();
	}
}

如果输入参数是两个，这是可以使用
BiFunction<T,U,R> 记作 <T,U> -> R
BiConsumer<T,U> 记作 <T,U> -> void
BiPredicate<T,U> 记作 <T,U> -> boolean


例如计算两个字符串长度的BiFunction例子

public class MyBiFunction implements BiFunction<String, String, Integer> {
	@Override
	public Integer apply(String s1, String s2) {
		return s1.length() + s2.length();
	}
}

如果一个Function的输入参数类型和输入参数类型相同，即Function<T, T>，这时可以使用 UnaryOperator<T>
例如下面的例子，输入参数和输出参数类型都是String

public class MyUnaryOperator implements UnaryOperator<String> {
	@Override
	public String apply(String s) {
		return "Hello " + s;
	}
}

如果使用BiFunction时，两个输入参数和输出参数均是同一类型，即BiFunction<T, T, T>，这时可以使用BinaryOperator<T>
例如

public class MyBinaryOperator implements BinaryOperator<String> {
	@Override
	public String apply(String s1, String s2) {
		return s1 + s2;
	}
}

如果输入参数是基本类型，为了避免自动拆箱装箱，可以使用
DoubleConsumer 记作 double -> void
DoubleFunction<R> 记作 double -> R
DoublePredicate 记作 double -> boolean
DoubleSupplier 记作 void -> double


IntConsumer 记作 int -> void
IntFunction<R> 记作 int -> R
IntPredicate 记作 int -> boolean
IntSupplier 记作 void -> int


LongConsumer 记作 long -> void
LongFunction<R> 记作 long -> R
LongPredicate 记作 long -> boolean
LongSupplier 记作 void -> long


LongToDoubleFunction 记作 long -> double
LongToIntFunction 记作 long -> double
DoubleToLongFunction 记作 double -> long
DoubleToIntFunction 记作 double -> int
IntToLongFunction 记作 int -> long
IntToDoubleFunction 记作 int -> double


ToIntFunction<T> 记作 T -> int
ToDoubleFunction<T> 记作 T -> double
ToLongFunction<T> 记作 T -> long


ToIntBiFunction<T,U> 记作 <T,U> -> int
ToDoubleBiFunction<T,U> 记作 <T,U> -> double
ToLongBiFunction<T,U> 记作 <T,U> -> long
 
IntBinaryOperator 记作 <int, int> -> int
IntUnaryOperator 记作 int -> int
DoubleBinaryOperator 记作 <double, double> -> double
DoubleUnaryOperator 记作 double -> double
LongBinaryOperator 记作 <long, long> -> long
LongUnaryOperator 记作 long -> long


ObjDoubleConsumer<T> 记作 <T, double> -> void
ObjIntConsumer<T>  记作 <T, int> -> void
ObjLongConsumer<T>  记作 <T, long> -> void