java 1.8函数式编程_java8 -函数式编程之Lambda表达式

1 前言

java 8已经流行很多年了，springboot 2、spring 5 等开源代码也已经开始使用大量函数式编程。为了跟上潮流和看懂一些源码，下面我们一起学习java8的函数式编程。由于在lambda的学习过程中，不免会用到函数式编程中的一些接口，我们先学习一些简单的函数式编程接口。

2 函数式编程接口

在 java 8 的java.util.function 包中提供了一些最常用的函数式接口。

四个最基本的函数接口

四个函数式接口是函数式编程的基础，可以通过学习 java8 -函数式编程之四个基本接口 充分了解该接口的用法。

Function：R apply(T t)；输入类型T返回类型R。

Consumer：void accept(T t)；输入类型T，“消费”掉，无返回。

Predicate：boolean test(T t)；输入类型T，并进行条件“判断”，返回true|false。

Supplier：T get()；无输入，“生产”一个T类型的返回值。

除了上面的基本操作接口，还有一些常用接口。

基本数据类型的函数式接口

double类型的函数式接口

DoubleFunction：R apply(double value);

DoubleConsumer：void accept(double value);

DoublePredicate：boolean test(double value);

DoubleSupplier：double getAsDouble();

int类型的函数式接口

IntFunction：R apply(int value);

IntConsumer：void accept(int value);

IntPredicate：boolean test(int value);

IntSupplier：int getAsInt();

long类型的函数式接口

LongFunction：R apply(long value);

LongConsumer：void accept(long value);

LongPredicate：boolean test(long value);

LongSupplier：long getAsLong();

boolean类型的函数式接口

BooleanSupplier：boolean getAsBoolean();

一元函数式接口

引用类型

UnaryOperator extends Function：T apply(T t);

基本数据类型

IntUnaryOperator：int applyAsInt(int operand);

LongUnaryOperator：long applyAsLong(long operand);

DoubleUnaryOperator：double applyAsDouble(double operand);

用于类型转换的一元函数式接口

引用类型转基本数据类型

ToDoubleFunction：double applyAsDouble(T value);

ToIntFunction：int applyAsInt(T value);

ToLongFunction：long applyAsLong(T value);

double类型转其他类型

DoubleToIntFunction：int applyAsInt(double value);

DoubleToLongFunction：long applyAsLong(double value);

由double得到引用类型就是前面的DoubleFunction：R apply(double value);

int类型转其他类型

IntToDoubleFunction：double applyAsDouble(int value);

IntToLongFunction：long applyAsLong(int value);

由int得到引用类型就是前面的IntFunction：R apply(int value);

long类型转其他类型

LongToDoubleFunction：double applyAsDouble(long value);

LongToIntFunction：int applyAsInt(long value);

由long得到引用类型就是前面的LongFunction：R apply(long value);

同类型输入的二元函数式接口

引用类型

BinaryOperator extends BiFunction：T apply(T left, T right)

基本数据类型

IntBinaryOperator：int applyAsInt(int left, int right);

LongBinaryOperator：long applyAsLong(long left, long right);

DoubleBinaryOperator：double applyAsDouble(double left, double right);

混合类型输入的二元函数式接口

ObjDoubleConsumer：void accept(T t, double value);

ObjIntConsumer：void accept(T t, int value);

ObjLongConsumer：void accept(T t, long value);

引用类型到基本数据类型的二元函数式接口

ToDoubleBiFunction：double applyAsDouble(T t, U u);

ToIntBiFunction：int applyAsInt(T t, U u);

ToLongBiFunction：long applyAsLong(T t, U u);

3 lambda表达式语法

Lambda表达式是Java8的新语法糖。它其实是一个匿名函数，可以把 Lambda表达式理解为一段约定好怎么传递参数和返回参数的一段代码，由编译器负责参数类型的猜测并执行结果。我们通过lambda表达式可以写出更简洁、更灵活的代码。

Lambda表达式的基本语法如下

(parameters) -> expression

或

(parameters) -> { statements; }

即"->"操作符将Lambda表达式分为两个部分：左侧为参数列表，右侧为Lambda体。

下面看下具体的语法：

无参数，无返回值

() -> System.out.println(“Helo”)

或者

() -> {

System.out.println("hello");

};

无参数，有返回值

() -> 10;

有一个参数，无返回值

(x) -> System.out.println(x)

或者

x -> System.out.print(x)

或者

(x) -> {

System.out.println(x);

};

有一个参数，有返回值

x -> x + 10;

或者

(x) -> x + 10;

或者

(x) -> {

return x + 10;

};

有多个参数，没有返回值

(x, y) -> {

System.out.println(x);

System.out.println(y);

};

或者

(Integer x, String y) -> {

System.out.println(x);

System.out.println(y);

};

有多个参数，有返回值

(x, y) -> x + y;

或者

(Integer x, Integer y) -> x + y;

或者

(Integer x, Integer y) -> {

return x + y;

};

其实，每个lambda表达式的返回值都是一个函数式编程的接口。

下面看下lambda表达式怎么使用。

//无参数，无返回值

Runnable runnable = () -> System.out.println("hello");

new Thread(runnable).start();

//无参数，有返回值

Supplier supplier = () -> 10;

Integer number = supplier.get();

System.out.println(number);

//有一个参数，无返回值

// Consumer consumer = (x) -> System.out.println(x);

Consumer consumer = (x) -> {

System.out.println(x);

};

consumer.accept("hello");

//有一个参数，有返回值

// Function function = x -> x + 10;

// Function function = (x) -> x + 10;

Function function = (x) -> {

return x + 10;

};

int result = function.apply(20);

System.out.println(result);

//多个参数，没有返回值

// BiConsumer consumer1 = (x, y) -> {

// System.out.println(x);

// System.out.println(y);

// };

BiConsumer consumer1 = (Integer x, String y) -> {

System.out.println(x);

System.out.println(y);

};

consumer1.accept(100, "hello");

//多个参数，有返回值

// BiFunction function1 = (x, y) -> x + y;

// BiFunction function1 = (Integer x, Integer y) -> x + y;

BiFunction function1 = (Integer x, Integer y) -> {

return x + y;

};

int result1 = function1.apply(10, 10);

System.out.println(result1);

相关资料

Java 8 函数式编程系列