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