java8 -函数式编程之Lambda表达式

1 前言

        java 8已经流行不少年了，springboot 二、spring 5 等开源代码也已经开始使用大量函数式编程。为了跟上潮流和看懂一些源码，下面咱们一块儿学习java8的函数式编程。因为在lambda的学习过程当中，难免会用到函数式编程中的一些接口，咱们先学习一些简单的函数式编程接口。

2 函数式编程接口

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

四个最基本的函数接口

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

• Function<T, R>：R apply(T t)；输入类型T返回类型R。
• Consumer<T>：void accept(T t)；输入类型T，“消费”掉，无返回。
• Predicate<T>：boolean test(T t)；输入类型T，并进行条件“判断”，返回true|false。
• Supplier<T>：T get()；无输入，“生产”一个T类型的返回值。

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

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

double类型的函数式接口

• DoubleFunction<R>：R apply(double value);
• DoubleConsumer：void accept(double value);
• DoublePredicate：boolean test(double value);
• DoubleSupplier：double getAsDouble();

int类型的函数式接口

• IntFunction<R>：R apply(int value);
• IntConsumer：void accept(int value);
• IntPredicate：boolean test(int value);
• IntSupplier：int getAsInt();

long类型的函数式接口

• LongFunction<R>：R apply(long value);
• LongConsumer：void accept(long value);
• LongPredicate：boolean test(long value);
• LongSupplier：long getAsLong();

boolean类型的函数式接口

• BooleanSupplier：boolean getAsBoolean();

一元函数式接口

引用类型

• UnaryOperator<T> extends Function<T, T>：T apply(T t);

基本数据类型

• IntUnaryOperator：int applyAsInt(int operand);
• LongUnaryOperator：long applyAsLong(long operand);
• DoubleUnaryOperator：double applyAsDouble(double operand);

 

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

引用类型转基本数据类型

• ToDoubleFunction<T>：double applyAsDouble(T value);
• ToIntFunction<T>：int applyAsInt(T value);
• ToLongFunction<T>：long applyAsLong(T value);

    double类型转其余类型

• DoubleToIntFunction：int applyAsInt(double value);
• DoubleToLongFunction：long applyAsLong(double value);

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

int类型转其余类型

• IntToDoubleFunction：double applyAsDouble(int value);

• IntToLongFunction：long applyAsLong(int value);

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

long类型转其余类型

• LongToDoubleFunction：double applyAsDouble(long value);
• LongToIntFunction：int applyAsInt(long value);

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

 

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

引用类型

• BinaryOperator<T> extends BiFunction<T,T,T>：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<T>：void accept(T t, double value);
• ObjIntConsumer<T>：void accept(T t, int value);
• ObjLongConsumer<T>：void accept(T t, long value);

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

 

• ToDoubleBiFunction<T, U>：double applyAsDouble(T t, U u);
• ToIntBiFunction<T, U>：int applyAsInt(T t, U u);
• ToLongBiFunction<T, U>：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<Integer> supplier = () -> 10;
Integer number = supplier.get();
System.out.println(number);

 

//有一个参数，无返回值
//  Consumer<String> consumer = (x) -> System.out.println(x);
Consumer<String> consumer = (x) -> {
    System.out.println(x);
};
consumer.accept("hello");

 

//有一个参数，有返回值
//  Function<Integer,Integer> function = x -> x + 10;
//  Function<Integer,Integer> function = (x) -> x + 10;
Function<Integer, Integer> function = (x) -> {
    return x + 10;
};
int result = function.apply(20);
System.out.println(result);

 

//多个参数，没有返回值
//  BiConsumer<Integer, String> consumer1 = (x, y) -> {
//      System.out.println(x);
//      System.out.println(y);
//  };
BiConsumer<Integer, String> consumer1 = (Integer x, String y) -> {
    System.out.println(x);
    System.out.println(y);
};
consumer1.accept(100, "hello");

 

//多个参数，有返回值
//  BiFunction<Integer, Integer, Integer> function1 = (x, y) -> x + y;
//  BiFunction<Integer, Integer, Integer> function1 = (Integer x, Integer y) -> x + y;
BiFunction<Integer, Integer, Integer> function1 = (Integer x, Integer y) -> {
    return x + y;
};
int result1 = function1.apply(10, 10);
System.out.println(result1);

相关资料

Java 8 函数式编程系列

    java8 -函数式编程之Lambda表达式

    java8 -函数式编程之四个基本接口

    java8 -函数式编程之Optional

    java8 -函数式编程之Stream