首页手记 Spring-Web-Flux实战(二) -...

Spring-Web-Flux实战(二) - 函数式编程和 lambda 表达式

标签：

Java 面试

1 函数接口

接口方法

引言

目前由于系统已经全面切换为JDK8，所以有必要系统的了解一下Java8的一些新特性，以便后续在日常工作中可以使用一些高级特性来提高编程效率。

因为Java8引入了函数式接口，在java.util.function包含了几大类函数式接口声明。这里第一篇主要研究一下Function相关的接口。

FunctionalInterface注解
Java8的新引入，包含函数式的设计，接口都有@FunctionalInterface的注解。就像这个注解的注释说明一样，它注解在接口层面，且注解的接口要有且仅有一个抽象方法。具体就是说，注解在Inteface上，且interface里只能有一个抽象方法，可以有default方法。因为从语义上来讲，一个函数式接口需要通过一个逻辑上的方法表达一个单一函数。那理解这个单一就很重要了，单一不是说限制你一个interface里只有一个抽象方法，单是多个方法的其他方法需要是继承自Object的public方法，或者你要想绕过，就自己实现default。函数式接口自己本身一定是只有一个抽象方法。同时，如果是Object类的public方法，也是不允许的。官方的说明翻译如下：

如果一个接口I，I有一组抽象方法集合M，且这些方法都不是Object类的public签名方法，那么如果存在一个M中的方法m，满足：

m的签名是所有M中方法签名的子签名。
m对于M中的每个方法都是返回类型可替换的。
此时，接口I是一个函数式接口。

怎么理解，看几个例子。

比如：你声明一个接口：

@FunctionalInterface
public interface Func {
}
这会编译错，编译器会告诉你no target method。而如果加一个方法：

@FunctionalInterface
public interface Func {
void run();
}
这就OK了，一个函数式接口声明好了。再加一个呢？

@FunctionalInterface
public interface Func {
void run();
void foo();
}
不ok，明确说了只有一个抽象方法嘛。但是如果换一种函数签名：

@FunctionalInterface
public interface Func {
boolean equals(Object obj);
}
错误依旧，因为这个方法签名是Object类的public方法。而再改一下：

@FunctionalInterface
public interface Func {
boolean equals(Object obj);
void run();
}
这就OK了。一个抽象方法，一个Object的public方法，相安无事。Object还有其他方法，clone方法试试会怎么样？

@FunctionalInterface
public interface Func {
Object clone();
void run();
}
这又不行了，因为前面明确说了，要是Object的public方法，而clone是protected的。

所以总结一句话就是：

函数式接口，有且仅有一个抽象方法，Object的public方法除外。

因为Java本身支持多接口实现，你定义一个Class可以implements多个interface。所以这个限制也没什么影响，如果想约定一个函数式接口来统一，也可以做一些默认的实现来达到一个接口多个抽象方法的目的，比如下面这种做法：
一个普通接口NonFunc：

public interface NonFunc {
void foo();
void voo();
}
函数式接口Func：

@FunctionalInterface
public interface Func extends NonFunc {
void run();
default void foo() {
// do something
}
default void voo() {
// do something
}
}
实现的测试类：

public class TestJ8FunctionalInterface implements Func {
public static void main(String[] args) {
Func func = new TestJ8FunctionalInterface();
func.run();
func.foo();
func.voo();
}
@Override
public void run() {
System.out.println(“run”);
}
@Override
public void foo() {
System.out.println(“foo”);
}
@Override
public void voo() {
System.out.println(“voo”);
}
}
函数式接口的一大特性就是可以被lambda表达式和函数引用表达式代替。也就是说声明这样的接口，是可以灵活的以方法来传参。看个例子：

public class TestJ8FunctionalInterface2 {
public static void main(String[] args) {
TestJ8FunctionalInterface2 testJ8FunctionalInterface2 = new TestJ8FunctionalInterface2();
// lambda
testJ8FunctionalInterface2.test(10, () -> System.out.println(“A customed Func.”));
// method reference
testJ8FunctionalInterface2.test(100, testJ8FunctionalInterface2::customedFunc);
}
public void customedFunc() {
System.out.println(“A customed method reference.”);
}
public void test(int x, Func func) {
System.out.println(x);
func.run();
}
}
上面例子列举了一个lambda模式和一个方法引用模式，这样就可以利用函数式编程强大的能力，将方法作为参数了。

另一个大的话题是针对上文的逻辑上的方法。所谓逻辑上，就是说当你出现函数式接口多重继承其他接口时，如果继承的多个接口有相同的方法签名，那么也是OK的。而这种相同签名的方法，也包括了泛型的情况，以下的声明中的Z接口，都是函数式接口。

interface X { int m(Iterable arg); }
interface Y { int m(Iterable arg); }
interface Z extends X, Y {}
interface X { int m(Iterable arg); }
interface Y { int m(Iterable arg); }
interface Z extends X, Y {}
但是要注意的是，这种泛型的支持，是因为函数式接口的官方声明规范里要求类型可替换和子签名，不是因为泛型擦除。
比如下面的例子就不是函数式接口：

interface X { int m(Iterable arg); }
interface Y { int m(Iterable arg); }
interface Z extends X, Y {}
interface X { int m(Iterable arg, Class c); }
interface Y { int m(Iterable arg, Class<?> c); }
interface Z extends X, Y {}
interface X { void m(T arg); }
interface Y { void m(T arg); }
interface Z<A, B> extends X, Y {}
最后，Java8里关于函数式接口的包是java.util.function，里面全部是函数式接口。主要包含几大类：Function、Predicate、Supplier、Consumer和*Operator（没有Operator接口，只有类似BinaryOperator这样的接口）。后面依次展开详细说明一下。

Function
关于Function接口，其接口声明是一个函数式接口，其抽象表达函数为

@FunctionalInterface
public interface Function<T, R> {
R apply(T t);
…
}
函数意为将参数T传递给一个函数，返回R。即
其默认实现了3个default方法，分别是compose、andThen和identity，对应的函数表达为：compose对应，体现嵌套关系；andThen对应，转换了嵌套的顺序；还有identity对应了一个传递自身的函数调用对应。从这里看出来，compose和andThen对于两个函数f和g来说，f.compose(g)等价于g.andThen(f)。看个例子：

public class TestFunction {
public static void main(String[] args) {
Function<Integer, Integer> incr1 = x -> x + 1;
Function<Integer, Integer> multiply = x -> x * 2;
int x = 2;
System.out.println(“f(x)=x+1,when x=” + x + “, f(x)=” + incr1.apply(x));
System.out.println(“f(x)=x+1,g(x)=2x, when x=” + x + “, f(g(x))=” + incr1.compose(multiply).apply(x));
System.out.println(“f(x)=x+1,g(x)=2x, when x=” + x + “, g(f(x))=” + incr1.andThen(multiply).apply(x));
System.out.println(“compose vs andThen:f(g(x))=” + incr1.compose(multiply).apply(x) + “,” + multiply.andThen(incr1).apply(x));
}
}
高阶函数
只是普通的lambda表达式，其能力有限。我们会希望引入更强大的函数能力——高阶函数，可以定义任意同类计算的函数。

Function<Integer, Function<Integer, Integer>> makeAdder = z -> y -> z + y;
比如这个函数定义，参数是z，返回值是一个Function，这个Function本身又接受另一个参数y，返回z+y。于是我们可以根据这个函数，定义任意加法函数：

    //high order function
    Function<Integer, Function<Integer, Integer>> makeAdder = z -> y -> z + y;
    x = 2;
    //define add1
    Function<Integer, Integer> add1 = makeAdder.apply(1);
    System.out.println("f(x)=x+1,when x=" + x + ", f(x)=" + add1.apply(x));
    //define add5
    Function<Integer, Integer> add5 = makeAdder.apply(5);
    System.out.println("f(x)=x+5,when x=" + x + ", f(x)=" + add5.apply(x));

由于高阶函数接受一个函数作为参数，结果返回另一个函数，所以是典型的函数到函数的映射。

BiFunction提供了二元函数的一个接口声明，举例来说：

    //binary function
    BiFunction<Integer, Integer, Integer> multiply = (a, b) -> a * b;
    System.out.println("f(z)=x*y, when x=3,y=5, then f(z)=" + multiply.apply(3, 5));

其输出结果将是：f(z)=x*y, when x=3,y=5, then f(z)=15。
二元函数没有compose能力，只是默认实现了andThen。

有了一元和二元函数，那么可以通过组合扩展出更多的函数可能。

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，函数有时候也叫作算子。算子在Java8中接口描述更像是函数的补充，和上面的很多类型映射型函数类似。

算子Operator包括：UnaryOperator和BinaryOperator。分别对应单元算子和二元算子。
算子的接口声明如下：

@FunctionalInterface
public interface UnaryOperator extends Function<T, T> {
static UnaryOperator identity() {
return t -> t;
}
二元算子的声明：

@FunctionalInterface
public interface BinaryOperator extends BiFunction<T,T,T> {
/**
* Returns a {@link BinaryOperator} which returns the lesser of two elements
* according to the specified {@code Comparator}.
*
* @param the type of the input arguments of the comparator
* @param comparator a {@code Comparator} for comparing the two values
* @return a {@code BinaryOperator} which returns the lesser of its operands,
* according to the supplied {@code Comparator}
* @throws NullPointerException if the argument is null
/
public static BinaryOperator minBy(Comparator<? super T> comparator) {
Objects.requireNonNull(comparator);
return (a, b) -> comparator.compare(a, b) <= 0 ? a : b;
}
/*
* Returns a {@link BinaryOperator} which returns the greater of two elements
* according to the specified {@code Comparator}.
*
* @param the type of the input arguments of the comparator
* @param comparator a {@code Comparator} for comparing the two values
* @return a {@code BinaryOperator} which returns the greater of its operands,
* according to the supplied {@code Comparator}
* @throws NullPointerException if the argument is null
*/
public static BinaryOperator maxBy(Comparator<? super T> comparator) {
Objects.requireNonNull(comparator);
return (a, b) -> comparator.compare(a, b) >= 0 ? a : b;
}
}
很明显，算子就是一个针对同类型输入输出的一个映射。在此接口下，只需声明一个泛型参数T即可。对应上面的例子：

public class TestOperator {
public static void main(String[] args) {
UnaryOperator add = x -> x + 1;
System.out.println(add.apply(1));
BinaryOperator addxy = (x, y) -> x + y;
System.out.println(addxy.apply(3, 5));
BinaryOperator min = BinaryOperator.minBy((o1, o2) -> o1 - o2);
System.out.println(min.apply(100, 200));
BinaryOperator max = BinaryOperator.maxBy((o1, o2) -> o1 - o2);
System.out.println(max.apply(100, 200));
}
}
例子里补充一点的是，BinaryOperator提供了两个默认的static快捷实现，帮助实现二元函数min(x,y)和max(x,y)，使用时注意的是排序器可别传反了：）

其他的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是一个谓词函数，主要作为一个谓词演算推导真假值存在，其意义在于帮助开发一些返回bool值的Function。本质上也是一个单元函数接口，其抽象方法test接受一个泛型参数T，返回一个boolean值。等价于一个Function的boolean型返回值的子集。

@FunctionalInterface
public interface Predicate {
boolean test(T t);
…
}
其默认方法也封装了and、or和negate逻辑。写个小例子看看：

public class TestJ8Predicate {
public static void main(String[] args) {
TestJ8Predicate testJ8Predicate = new TestJ8Predicate();
testJ8Predicate.printBigValue(10, val -> val > 5);
testJ8Predicate.printBigValueAnd(10, val -> val > 5);
testJ8Predicate.printBigValueAnd(6, val -> val > 5);
//binary predicate
BiPredicate<Integer, Long> biPredicate = (x, y) -> x > 9 && y < 100;
System.out.println(biPredicate.test(100, 50L));
}
public void printBigValue(int value, Predicate predicate) {
if (predicate.test(value)) {
System.out.println(value);
}
}
public void printBigValueAnd(int value, Predicate predicate) {
if (predicate.and(v -> v < 8).test(value)) {
System.out.println("value < 8 : " + value);
} else {
System.out.println(“value should < 8 at least.”);
}
}
}
Predicate在Stream中有应用，Stream的filter方法就是接受Predicate作为入参的。这个具体在后面使用Stream的时候再分析深入。

其他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

看名字就可以想到，这像谓词函数接口一样，也是一个Function接口的特殊表达 —— 接受一个泛型参数，不需要返回值的函数接口.

这个接口声明太重要了，对于一些纯粹consume型的函数，没有Consumer的定义真无法被Function家族的函数接口表达.
因为Function一定需要一个泛型参数作为返回值类型（当然不排除你使用Function来定义，但是一直返回一个无用的值）.
比如下面的例子，如果没有Consumer，类似的行为使用Function表达就一定需要一个返回值。

public class TestJ8Consumer {
    public static void main(String[] args) {
        Consumer<Integer> consumer = System.out::println;
        consumer.accept(100);
        //use function, you always need one return value.
        Function<Integer, Integer> function = x -> {
            System.out.println(x);
            return x;
        };
        function.apply(100);
    }
}

其他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

声明如下：

其简洁的声明，会让人以为不是函数。
该抽象方法的声明，同Consumer相反，是一个只声明返回值,不需要参数的函数（这TM是函数？）.
也就是说 Supplier 其实表达的不是从一个参数空间到结果空间的映射能力，而是表达一种生产能力，因为我们常见的场景中不止是要consume（Consumer）或者是简单的map（Function），还包括了new这个动作.
而 Supplier 就表达了这种能力。

比如你要是返回一个常量，那可以使用类似的做法：

这保证supply对象输出的一直是1.
如果要利用构造函数的能力呢？就可以这样：

这样的输出可以看到，全部的对象都是new出来的.

这样的场景在Stream计算中会经常用到.

其他Supplier接口：

BooleanSupplier：boolean getAsBoolean();返回boolean
DoubleSupplier：double getAsDouble();返回double
IntSupplier：int getAsInt();返回int
LongSupplier：long getAsLong();返回long

方法引用

package lambda;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.IntUnaryOperator;

class Dog {
   private String name = "哮天犬";

   /**
    * 默认10斤狗粮
    */
   private int food = 10;

   public Dog() {

   }

   /**
    * 带参数的构造函数
    * 
    * @param name
    */
   public Dog(String name) {
   	this.name = name;
   }

   /**
    * 狗叫，静态方法
    * 
    * @param dog
    */
   public static void bark(Dog dog) {
   	System.out.println(dog + "叫了");
   }

   /**
    * 吃狗粮 JDK
    * 
    * 默认会把当前实例传入到非静态方法，参数名为this，位置是第一个；
    * 
    * @param num
    * @return 还剩下多少斤
    */
   public int eat(int num) {
   	System.out.println("吃了" + num + "斤狗粮");
   	this.food -= num;
   	return this.food;
   }

   @Override
   public String toString() {
   	return this.name;
   }
}

/**
* @author shishusheng
*/
public class MethodRefrenceDemo {

   public static void main(String[] args) {
   	Dog dog = new Dog();
   	dog.eat(3);

   	// 方法引用
   	Consumer<String> consumer = System.out::println;
   	consumer.accept("接受的数据");

   	// 静态方法的方法引用
   	Consumer<Dog> consumer2 = Dog::bark;
   	consumer2.accept(dog);

   	// 非静态方法，使用对象实例的方法引用
   	// Function<Integer, Integer> function = dog::eat;
   	// UnaryOperator<Integer> function = dog::eat;
   	IntUnaryOperator function = dog::eat;
   	
   	// dog置空，不影响下面的函数执行，因为java 参数是传值
   	dog = null;
   	System.out.println("还剩下" + function.applyAsInt(2) + "斤");
   	//
   	// // 使用类名来方法引用
   	// BiFunction<Dog, Integer, Integer> eatFunction = Dog::eat;
   	// System.out.println("还剩下" + eatFunction.apply(dog, 2) + "斤");
   	//
   	// // 构造函数的方法引用
   	// Supplier<Dog> supplier = Dog::new;
   	// System.out.println("创建了新对象：" + supplier.get());
   	//
   	// // 带参数的构造函数的方法引用
   	// Function<String, Dog> function2 = Dog::new;
   	// System.out.println("创建了新对象：" + function2.apply("旺财"));

   	// 测试java变量是传值还是穿引用
   	List<String> list = new ArrayList<>();
   	test(list);

   	System.err.println(list);
   }

   private static void test(List<String> list) {
   	list = null;
   }
}

#类型推断

#变量引用