java函数编程（lambda）
java函数编程（lambda）
什么是lambda
java的lambda是java8的新特性（现在都要出java12了，才来聊这个东东，显得有点落后。不得不说，如果不是有一次看谁的代码，看到这行代码：“System.out::println”，我还不知道java已经有了这个东西…），简单的说就是把自定义方法当成参数传递。我最早接触函数编程的语言应该是js，当时见到可以在传参中写那么大一段代码时：“WC，居然还可以这么干”。现在没想到java也可以这么干了。相对于弱类型语言的js来说，java的这个新功能看起来就没那么简单了（虽然它有根据上下文推测变量类型的功能）。
废话不多说，进入正题吧。
关于java的lambda
java的lambda就是一个一个的接口类，java规定lambda接口中有且仅有一个抽象接口，多了不行，没有也不行。在自定义lambda接口时，最好给类加上@FunctionalInterface注解，@FunctionalInterface注解的作用是告诉编译器检查当前接口是不是只包含一个抽象方法。具体就是说，注解在Inteface上，且interface里只能有一个抽象方法，可以有default方法。因为从语义上来讲，一个函数式接口需要通过一个逻辑上的方法表达一个单一函数。那理解这个单一就很重要了，单一不是说限制你一个interface里只有一个抽象方法，单是多个方法的其他方法需要是继承自Object的public方法，或者你要想绕过，就自己实现default。函数式接口自己本身一定是只有一个抽象方法。同时，如果是Object类的public方法，也是不允许的。官方的说明翻译如下：
如果一个接口I，I有一组抽象方法集合M，且这些方法都不是Object类的public签名方法，那么如果存在一个M中的方法m，满足：
m的签名是所有M中方法签名的子签名。
m对于M中的每个方法都是返回类型可替换的。 此时，接口I是一个函数式接口。
简单的lambda实现
自定义一个函数接口（也可以用java自带的Function接口）：
@FunctionalInterface
public interface LambdaTest<T, R> {
// 这是带有返回值的抽象方法
R test(T t);
}
测试代码：
public class MyLambdaTest {
public static void main(String[] args){
lambdaTest(x -> x + 1);
}
private static void lambdaTest(LambdaTest<Integer, Integer> fun) {
Integer a = 2;
System.out.println(fun.test(a));
}
}
输出：
3
可以看到，lambdaTest方法的入参是一个接口，在调用的时候，直接将方法内容传进去，也就是代码中的
x -> x + 1
表达式使用“->”连接，左边为入参，右边为执行代码。参数可以表明类型，可以省略。当没有指明参数类型时，java会根据上下文自主来判断入参的类型。如果带上参数类型的话，就需要用括号包起来，想这样“(Integer x)”。右边为自定义执行代码（相当于方法体），可以是一句，可以是几句，当有几句代码时，需要用“{}”包围，当使用了“{}”并且方法需要有返回值时，必须要写return：
public class MyLambdaTest {
public static void main(String[] args){
lambdaTest((Integer x) -> {
System.out.println(x);
return x + 1;
});
}
private static void lambdaTest(LambdaTest<Integer, Integer> fun) {
Integer a = 2;
System.out.println(fun.test(a));
}
}
输出：
2
3
java自带函数接口
在jdk中，实现了很多的函数接口，它们都定义在java.util.function包下，大致可以分为这几类：Function、Predicate、Supplier、Consumer和*Operator（没有Operator接口，只有类似BinaryOperator这样的接口），我们来看看这些接口：
Function
@FunctionalInterface
public interface Function<T, R> {
R apply(T t);
...
}
函数意为将参数T传递给一个函数，返回R。即R=Function(T)R=Function(T)
其默认实现了3个default方法，分别是compose、andThen和identity，对应的函数表达为：compose对应V=Function(ParamFunction(T))V=Function(ParamFunction(T))，体现嵌套关系；andThen对应V=ParamFunction(Function(T))V=ParamFunction(Function(T))，转换了嵌套的顺序；还有identity对应了一个传递自身的函数调用对应Function(T)=TFunction(T)=T。从这里看出来，compose和andThen对于两个函数f和g来说，f.compose(g)等价于g.andThen(f)。
Function接口相关的接口包括：
BiFunction ：R apply(T t, U u);接受两个参数，返回一个值，代表一个二元函数；
DoubleFunction ：R apply(double value);只处理double类型的一元函数；
IntFunction ：R apply(int value);只处理int参数的一元函数；
LongFunction ：R apply(long value);只处理long参数的一元函数；
ToDoubleFunction：double applyAsDouble(T value);返回double的一元函数；
ToDoubleBiFunction：double applyAsDouble(T t, U u);返回double的二元函数；
ToIntFunction：int applyAsInt(T value);返回int的一元函数；
ToIntBiFunction：int applyAsInt(T t, U u);返回int的二元函数；
ToLongFunction：long applyAsLong(T value);返回long的一元函数；
ToLongBiFunction：long applyAsLong(T t, U u);返回long的二元函数；
DoubleToIntFunction：int applyAsInt(double value);接受double返回int的一元函数；
DoubleToLongFunction：long applyAsLong(double value);接受double返回long的一元函数；
IntToDoubleFunction：double applyAsDouble(int value);接受int返回double的一元函数；
IntToLongFunction：long applyAsLong(int value);接受int返回long的一元函数；
LongToDoubleFunction：double applyAsDouble(long value);接受long返回double的一元函数；
LongToIntFunction：int applyAsInt(long value);接受long返回int的一元函数；
Operator
Operator其实就是一个返回值类型和参数类型一直的Function，其包括两个接口：UnaryOperator和BinaryOperator，UnaryOperator是一元函数：
@FunctionalInterface
public interface UnaryOperator<T> extends Function<T, T> {
static <T> UnaryOperator<T> identity() {
return t -> t;
}
}
BinaryOperator则是二元函数：
@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;
}
其他的Operator接口：（不解释了）
LongUnaryOperator：long applyAsLong(long operand);
IntUnaryOperator：int applyAsInt(int operand);
DoubleUnaryOperator：double applyAsDouble(double operand);
DoubleBinaryOperator：double applyAsDouble(double left, double right);
IntBinaryOperator：int applyAsInt(int left, int right);
LongBinaryOperator：long applyAsLong(long left, long right);
Predicate
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);
}
@SuppressWarnings("unchecked")
static <T> Predicate<T> not(Predicate<? super T> target) {
Objects.requireNonNull(target);
return (Predicate<T>)target.negate();
}
...
}
它除了抽象接口，还默认提供了and、or、not和negate逻辑。
其他Predicate接口：
BiPredicate：boolean test(T t, U u);接受两个参数的二元谓词
DoublePredicate：boolean test(double value);入参为double的谓词函数
IntPredicate：boolean test(int value);入参为int的谓词函数
LongPredicate：boolean test(long value);入参为long的谓词函数
Consumer
这是一个不需要返回值的函数接口：
@FunctionalInterface
public interface Consumer<T> {
void accept(T t);
}
其他Consumer接口：
BiConsumer：void accept(T t, U u);接受两个参数
DoubleConsumer：void accept(double value);接受一个double参数
IntConsumer：void accept(int value);接受一个int参数
LongConsumer：void accept(long value);接受一个long参数
ObjDoubleConsumer：void accept(T t, double value);接受一个泛型参数一个double参数
ObjIntConsumer：void accept(T t, int value);接受一个泛型参数一个int参数
ObjLongConsumer：void accept(T t, long value);接受一个泛型参数一个long参数
Supplier
Supplier是一个不需要参数且有返回值的函数接口，它就像一个创造者：
@FunctionalInterface
public interface Supplier<T> {
T get();
}
其他Supplier接口：
BooleanSupplier：boolean getAsBoolean();返回boolean
DoubleSupplier：double getAsDouble();返回double
IntSupplier：int getAsInt();返回int
LongSupplier：long getAsLong();返回long
总结
整个函数式接口的大概总结如下：