詳解Java函數(shù)式編程和lambda表達式
為什么要使用函數(shù)式編程
函數(shù)式編程更多時候是一種編程的思維方式，是種方法論。函數(shù)式與命令式編程的區(qū)別主要在于：函數(shù)式編程是告訴代碼你要做什么，而命令式編程則是告訴代碼要怎么做。說白了，函數(shù)式編程是基于某種語法或調(diào)用API去進行編程。例如，我們現(xiàn)在需要從一組數(shù)字中，找出最小的那個數(shù)字，若使用用命令式編程實現(xiàn)這個需求的話，那么所編寫的代碼如下：
public static void main(String[] args) {
int[] nums = new int[]{1, 2, 3, 4, 5, 6, 7, 8};
int min = Integer.MAX_VALUE;
for (int num : nums) {
if (num < min) {
min = num;
}
}
System.out.println(min);
}
而使用函數(shù)式編程進行實現(xiàn)的話，所編寫的代碼如下：
public static void main(String[] args) {
int[] nums = new int[]{1, 2, 3, 4, 5, 6, 7, 8};
int min = IntStream.of(nums).min().getAsInt();
System.out.println(min);
}
從以上的兩個例子中，可以看出，命令式編程需要自己去實現(xiàn)具體的邏輯細節(jié)。而函數(shù)式編程則是調(diào)用API完成需求的實現(xiàn)，將原本命令式的代碼寫成一系列嵌套的函數(shù)調(diào)用，在函數(shù)式編程下顯得代碼更簡潔、易懂，這就是為什么要使用函數(shù)式編程的原因之一。所以才說函數(shù)式編程是告訴代碼你要做什么，而命令式編程則是告訴代碼要怎么做，是一種思維的轉變。
說到函數(shù)式編程就不得不提一下lambda表達式，它是函數(shù)式編程的基礎。在Java還不支持lambda表達式時，我們需要創(chuàng)建一個線程的話，需要編寫如下代碼：
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("running");
}
}).start();
}
而使用lambda表達式一句代碼就能完成線程的創(chuàng)建，lambda強調(diào)了函數(shù)的輸入輸出，隱藏了過程的細節(jié)，并且可以接受函數(shù)當作輸入（參數(shù)）和輸出（返回值）：
public static void main(String[] args) {
new Thread(() -> System.out.println("running")).start();
}
注：箭頭的左邊是輸入，右邊則是輸出。
該lambda表達式的作用其實就是返回了Runnable接口的實現(xiàn)對象，這與我們調(diào)用某個方法獲取實例對象類似，只不過是將實現(xiàn)代碼直接寫在了lambda表達式里。我們可以做個簡單的對比：
public static void main(String[] args) {
Runnable runnable1 = () -> System.out.println("running");
Runnable runnable2 = RunnableFactory.getInstance();
}
JDK8接口新特性
1.函數(shù)接口，接口只能有一個需要實現(xiàn)的方法，可以使用@FunctionalInterface 注解進行聲明。如下：
@FunctionalInterface
interface Interface1 {
int doubleNum(int i);
}
使用lambda表達式獲取該接口的實現(xiàn)實例的幾種寫法：
public static void main(String[] args) {
// 最常見的寫法
Interface1 i1 = (i) -> i * 2;
Interface1 i2 = i -> i * 2;
// 可以指定參數(shù)類型
Interface1 i3 = (int i) -> i * 2;
// 若有多行代碼可以這么寫
Interface1 i4 = (int i) -> {
System.out.println(i);
return i * 2;
};
}
2.比較重要的一個接口特性是接口的默認方法，用于提供默認實現(xiàn)。默認方法和普通實現(xiàn)類的方法一樣，可以使用this等關鍵字：
@FunctionalInterface
interface Interface1 {
int doubleNum(int i);
default int add(int x, int y) {
return x + y;
}
}
之所以說默認方法這個特性比較重要，是因為我們借助這個特性可以在以前所編寫的一些接口上提供默認實現(xiàn)，并且不會影響任何的實現(xiàn)類以及既有的代碼。例如我們最熟悉的List接口，在JDK1.2以來List接口就沒有改動過任何代碼，到了1.8之后才使用這個新特性增加了一些默認實現(xiàn)。這是因為如果沒有默認方法的特性的話，修改接口代碼帶來的影響是巨大的，而有了默認方法后，增加默認實現(xiàn)可以不影響任何的代碼。
3.當接口多重繼承時，可能會發(fā)生默認方法覆蓋的問題，這時可以去指定使用哪一個接口的默認方法實現(xiàn)，如下示例：
@FunctionalInterface
interface Interface1 {
int doubleNum(int i);
default int add(int x, int y) {
return x + y;
}
}
@FunctionalInterface
interface Interface2 {
int doubleNum(int i);
default int add(int x, int y) {
return x + y;
}
}
@FunctionalInterface
interface Interface3 extends Interface1, Interface2 {
@Override
default int add(int x, int y) {
// 指定使用哪一個接口的默認方法實現(xiàn)
return Interface1.super.add(x, y);
}
}
函數(shù)接口
我們本小節(jié)來看看JDK8里自帶了哪些重要的函數(shù)接口：
可以看到上表中有好幾個接口，而其中最常用的是Function接口，它能為我們省去定義一些不必要的函數(shù)接口，減少接口的數(shù)量。我們使用一個簡單的例子演示一下 Function 接口的使用：
import java.text.DecimalFormat;
import java.util.function.Function;
class MyMoney {
private final int money;
public MyMoney(int money) {
this.money = money;
}
public void printMoney(Function<Integer, String> moneyFormat) {
System.out.println("我的存款: " + moneyFormat.apply(this.money));
}
}
public class MoneyDemo {
public static void main(String[] args) {
MyMoney me = new MyMoney(99999999);
Function<Integer, String> moneyFormat = i -> new DecimalFormat("#,###").format(i);
// 函數(shù)接口支持鏈式操作，例如增加一個字符串
me.printMoney(moneyFormat.andThen(s -> "人民幣 " + s));
}
}
運行以上例子，控制臺輸出如下：
我的存款: 人民幣 99,999,999
若在這個例子中不使用Function接口的話，則需要自行定義一個函數(shù)接口，并且不支持鏈式操作，如下示例：
import java.text.DecimalFormat;
// 自定義一個函數(shù)接口
@FunctionalInterface
interface IMoneyFormat {
String format(int i);
}
class MyMoney {
private final int money;
public MyMoney(int money) {
this.money = money;
}
public void printMoney(IMoneyFormat moneyFormat) {
System.out.println("我的存款: " + moneyFormat.format(this.money));
}
}
public class MoneyDemo {
public static void main(String[] args) {
MyMoney me = new MyMoney(99999999);
IMoneyFormat moneyFormat = i -> new DecimalFormat("#,###").format(i);
me.printMoney(moneyFormat);
}
}
然后我們再來看看Predicate接口和Consumer接口的使用，如下示例：
public static void main(String[] args) {
// 斷言函數(shù)接口
Predicate<Integer> predicate = i -> i > 0;
System.out.println(predicate.test(-9));
// 消費函數(shù)接口
Consumer<String> consumer = System.out::println;
consumer.accept("這是輸入的數(shù)據(jù)");
}
運行以上例子，控制臺輸出如下：
false
這是輸入的數(shù)據(jù)
這些接口一般有對基本類型的封裝，使用特定類型的接口就不需要去指定泛型了，如下示例：
public static void main(String[] args) {
// 斷言函數(shù)接口
IntPredicate intPredicate = i -> i > 0;
System.out.println(intPredicate.test(-9));
// 消費函數(shù)接口
IntConsumer intConsumer = (value) -> System.out.println("輸入的數(shù)據(jù)是：" + value);
intConsumer.accept(123);
}
運行以上代碼，控制臺輸出如下：
false
輸入的數(shù)據(jù)是：123
有了以上接口示例的鋪墊，我們應該對函數(shù)接口的使用有了一個初步的了解，接下來我們演示剩下的函數(shù)接口使用方式：
public static void main(String[] args) {
// 提供數(shù)據(jù)接口
Supplier<Integer> supplier = () -> 10 + 1;
System.out.println("提供的數(shù)據(jù)是：" + supplier.get());
// 一元函數(shù)接口
UnaryOperator<Integer> unaryOperator = i -> i * 2;
System.out.println("計算結果為：" + unaryOperator.apply(10));
// 二元函數(shù)接口
BinaryOperator<Integer> binaryOperator = (a, b) -> a * b;
System.out.println("計算結果為：" + binaryOperator.apply(10, 10));
}
運行以上代碼，控制臺輸出如下：
提供的數(shù)據(jù)是：11
計算結果為：20
計算結果為：100
而BiFunction接口就是比Function接口多了一個輸入而已，如下示例：
class MyMoney {
private final int money;
private final String name;
public MyMoney(int money, String name) {
this.money = money;
this.name = name;
}
public void printMoney(BiFunction<Integer, String, String> moneyFormat) {
System.out.println(moneyFormat.apply(this.money, this.name));
}
}
public class MoneyDemo {
public static void main(String[] args) {
MyMoney me = new MyMoney(99999999, "小明");
BiFunction<Integer, String, String> moneyFormat = (i, name) -> name + "的存款: " + new DecimalFormat("#,###").format(i);
me.printMoney(moneyFormat);
}
}
運行以上代碼，控制臺輸出如下：
小明的存款: 99,999,999
方法引用
在學習了lambda表達式之后，我們通常會使用lambda表達式來創(chuàng)建匿名方法。但有的時候我們僅僅是需要調(diào)用一個已存在的方法。如下示例：
Arrays.sort(stringsArray, (s1, s2) -> s1.compareToIgnoreCase(s2));
在jdk8中，我們可以通過一個新特性來簡寫這段lambda表達式。如下示例：
Arrays.sort(stringsArray, String::compareToIgnoreCase);
這種特性就叫做方法引用(Method Reference)。方法引用的標準形式是：類名::方法名。（注意：只需要寫方法名，不需要寫括號）。
目前方法引用共有以下四種形式：
| 類型 | 示例 | 代碼示例 | 對應的Lambda表達式 |
|---|---|---|---|
| 引用靜態(tài)方法 | ContainingClass::staticMethodName | String::valueOf | (s) -> String.valueOf(s) |
| 引用某個對象的實例方法 | containingObject::instanceMethodName | x::toString() | () -> this.toString() |
| 引用某個類型的任意對象的實例方法 | ContainingType::methodName | String::toString | (s) -> s.toString |
| 引用構造方法 | ClassName::new | String::new | () -> new String() |
下面我們用一個簡單的例子來演示一下方法引用的幾種寫法。首先定義一個實體類：
public class Dog {
private String name = "二哈";
private int food = 10;
public Dog() {
}
public Dog(String name) {
this.name = name;
}
public static void bark(Dog dog) {
System.out.println(dog + "叫了");
}
public int eat(int num) {
System.out.println("吃了" + num + "斤");
this.food -= num;
return this.food;
}
@Override
public String toString() {
return this.name;
}
}
通過方法引用來調(diào)用該實體類中的方法，代碼如下：
package org.zero01.example.demo;
import java.util.function.*;
/**
* @ProjectName demo
* @Author: zeroJun
* @Date: 2018/9/21 13:09
* @Description: 方法引用demo
*/
public class MethodRefrenceDemo {
public static void main(String[] args) {
// 方法引用，調(diào)用打印方法
Consumer<String> consumer = System.out::println;
consumer.accept("接收的數(shù)據(jù)");
// 靜態(tài)方法引用，通過類名即可調(diào)用
Consumer<Dog> consumer2 = Dog::bark;
consumer2.accept(new Dog());
// 實例方法引用，通過對象實例進行引用
Dog dog = new Dog();
IntUnaryOperator function = dog::eat;
System.out.println("還剩下" + function.applyAsInt(2) + "斤");
// 另一種通過實例方法引用的方式，之所以可以這么干是因為JDK默認會把當前實例傳入到非靜態(tài)方法，參數(shù)名為this，參數(shù)位置為第一個，所以我們在非靜態(tài)方法中才能訪問this，那么就可以通過BiFunction傳入實例對象進行實例方法的引用
Dog dog2 = new Dog();
BiFunction<Dog, Integer, Integer> biFunction = Dog::eat;
System.out.println("還剩下" + biFunction.apply(dog2, 2) + "斤");
// 無參構造函數(shù)的方法引用，類似于靜態(tài)方法引用，只需要分析好輸入輸出即可
Supplier<Dog> supplier = Dog::new;
System.out.println("創(chuàng)建了新對象：" + supplier.get());
// 有參構造函數(shù)的方法引用
Function<String, Dog> function2 = Dog::new;
System.out.println("創(chuàng)建了新對象：" + function2.apply("旺財"));
}
}
最后需要說一句的就是能夠使用方法引用的地方就盡量不要使用lambda表達式，這樣就不會多生成一個類似 lambda$0這樣的函數(shù)，能夠減少一些資源的開銷。
類型推斷
通過以上的例子，我們知道之所以能夠使用Lambda表達式的依據(jù)是必須有相應的函數(shù)接口。這一點跟Java是強類型語言吻合，也就是說你并不能在代碼的任何地方任性的寫Lambda表達式。實際上Lambda的類型就是對應函數(shù)接口的類型。Lambda表達式另一個依據(jù)是類型推斷機制，在上下文信息足夠的情況下，編譯器可以推斷出參數(shù)表的類型，而不需要顯式指名。
所以說 Lambda 表達式的類型是從 Lambda 的上下文推斷出來的，上下文中 Lambda 表達式需要的類型稱為目標類型，如下圖所示：
接下來我們使用一個簡單的例子，演示一下 Lambda 表達式的幾種類型推斷，首先定義一個簡單的函數(shù)接口：
@FunctionalInterface
interface IMath {
int add(int x, int y);
}
示例代碼如下：
public class TypeDemo {
public static void main(String[] args) {
// 1.通過變量類型定義
IMath iMath = (x, y) -> x + y;
// 2.數(shù)組構建的方式
IMath[] iMaths = {(x, y) -> x + y};
// 3.強轉類型的方式
Object object = (IMath) (x, y) -> x + y;
// 4.通過方法返回值確定類型
IMath result = createIMathObj();
// 5.通過方法參數(shù)確定類型
test((x, y) -> x + y);
}
public static IMath createIMathObj() {
return (x, y) -> x + y;
}
public static void test(IMath iMath){
return;
}
}
變量引用
Lambda表達式類似于實現(xiàn)了指定接口的內(nèi)部類或者說匿名類，所以在Lambda表達式中引用變量和我們在匿名類中引用變量的規(guī)則是一樣的。如下示例：
public static void main(String[] args) {
String str = "當前的系統(tǒng)時間戳是: ";
Consumer<Long> consumer = s -> System.out.println(str + s);
consumer.accept(System.currentTimeMillis());
}
值得一提的是，在JDK1.8之前我們一般會將匿名類里訪問的外部變量設置為final，而在JDK1.8里默認會將這個匿名類里訪問的外部變量給設置為final。例如我現(xiàn)在改變str變量的值，ide就會提示錯誤：
至于為什么要將變量設置final，這是因為在Java里沒有引用傳遞，變量都是值傳遞的。不將變量設置為final的話，如果外部變量的引用被改變了，那么最終得出來的結果就會是錯誤的。
下面用一組圖片簡單演示一下值傳遞與引用傳遞的區(qū)別。以列表為例，當只是值傳遞時，匿名類里對外部變量的引用是一個值對象：
若此時list變量指向了另一個對象，那么匿名類里引用的還是之前那個值對象，所以我們才需要將其設置為final防止外部變量引用改變：
而如果是引用傳遞的話，匿名類里對外部變量的引用就不是值對象了，而是指針指向這個外部變量：
所以就算list變量指向了另一個對象，匿名類里的引用也會隨著外部變量的引用改變而改變：
級聯(lián)表達式和柯里化
在函數(shù)式編程中，函數(shù)既可以接收也可以返回其他函數(shù)。函數(shù)不再像傳統(tǒng)的面向對象編程中一樣，只是一個對象的工廠或生成器，它也能夠創(chuàng)建和返回另一個函數(shù)。返回函數(shù)的函數(shù)可以變成級聯(lián) lambda 表達式，特別值得注意的是代碼非常簡短。盡管此語法初看起來可能非常陌生，但它有自己的用途。
級聯(lián)表達式就是多個lambda表達式的組合，這里涉及到一個高階函數(shù)的概念，所謂高階函數(shù)就是一個可以返回函數(shù)的函數(shù)，如下示例：
// 實現(xiàn)了 x + y 的級聯(lián)表達式
Function<Integer, Function<Integer, Integer>> function1 = x -> y -> x + y;
System.out.println("計算結果為: " + function1.apply(2).apply(3)); // 計算結果為: 5
這里的 y -> x + y 是作為一個函數(shù)返回給上一級表達式，所以第一級表達式的輸出是 y -> x + y這個函數(shù)，如果使用括號括起來可能會好理解一些：
x -> (y -> x + y)
級聯(lián)表達式可以實現(xiàn)函數(shù)柯里化，簡單來說柯里化就是把本來多個參數(shù)的函數(shù)轉換為只有一個參數(shù)的函數(shù)，如下示例：
Function<Integer, Function<Integer, Function<Integer, Integer>>> function2 = x -> y -> z -> x + y + z;
System.out.println("計算結果為: " + function2.apply(1).apply(2).apply(3)); // 計算結果為: 6
如果大家想學習以上路線內(nèi)容，在此我向大家推薦一個架構學習交流群。交流學習群號874811168 里面會分享一些資深架構師錄制的視頻錄像：有Spring，MyBatis，Netty源碼分析，高并發(fā)、高性能、分布式、微服務架構的原理，JVM性能優(yōu)化、分布式架構等這些成為架構師必備的知識體系。還能領取免費的學習資源，目前受益良多
函數(shù)柯里化的目的是將函數(shù)標準化，函數(shù)可靈活組合，方便統(tǒng)一處理等，例如我可以在循環(huán)里只需要調(diào)用同一個方法，而不需要調(diào)用另外的方法就能實現(xiàn)一個數(shù)組內(nèi)元素的求和計算，代碼如下：
public static void main(String[] args) {
Function<Integer, Function<Integer, Function<Integer, Integer>>> f3 = x -> y -> z -> x + y + z;
int[] nums = {1, 2, 3};
for (int num : nums) {
if (f3 instanceof Function) {
Object obj = f3.apply(num);
if (obj instanceof Function) {
f3 = (Function) obj;
} else {
System.out.println("調(diào)用結束, 結果為: " + obj); // 調(diào)用結束, 結果為: 6
}
}
}
}
級聯(lián)表達式和柯里化一般在實際開發(fā)中并不是很常見，所以對其概念稍有理解即可，這里只是簡單帶過。
以上就是詳解Java函數(shù)式編程和lambda表達式的詳細內(nèi)容，更多關于Java函數(shù)式編程和lambda表達式的資料請關注腳本之家其它相關文章！
相關文章
其實spring?boot攔截器的配置方式和springMVC差不多,只有一些小的改變需要注意下就ok了。本文主要給大家介紹了關于如何在Springboot實現(xiàn)登陸攔截器功能,需要的朋友可以參考下2022-07-07
掌握idea的各種快捷鍵，可以幫助我們開發(fā)程序，今天小編給大家?guī)韼追N比較常用的idea快捷鍵及一些快捷鍵介紹，對idea快捷鍵相關知識，感興趣的朋友一起看看吧2021-05-05
這篇文章主要介紹了講解了在面試中jvm如何實現(xiàn)多態(tài)，怎樣回答才能得到高分的問題分析，有需要的朋友可以借鑒參考下，祝大家早日升職加薪多多進步2022-01-01
解讀maven項目中Tomcat10與JSTL的問題匯總(Debug親身經(jīng)歷)
這篇文章主要介紹了解讀maven項目中Tomcat10與JSTL的問題匯總(Debug親身經(jīng)歷)，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2023-07-07
關于Java中使用jdbc連接數(shù)據(jù)庫中文出現(xiàn)亂碼的問題
這篇文章主要介紹了關于Java中使用jdbc連接數(shù)據(jù)庫中文出現(xiàn)亂碼的問題,默認的編碼和數(shù)據(jù)庫表中的數(shù)據(jù)使用的編碼是不一致的，如果是中文，那么在數(shù)據(jù)庫中執(zhí)行時已經(jīng)是亂碼了,需要的朋友可以參考下2023-04-04
這篇文章主要介紹了Java的Jackson庫的使用及其樹模型入門學習教程,Jackson庫通常被用來作Java對象和JSON的互相轉換,需要的朋友可以參考下2016-01-01
java讀寫ini文件、FileOutputStream問題
這篇文章主要介紹了java讀寫ini文件、FileOutputStream問題，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2023-04-04
這篇文章主要介紹了舉例講解Java中的Stream流概念,是Java入門學習中的基礎知識,需要的朋友可以參考下2015-09-09
這篇文章主要介紹了Java面向對象之作用域詳細解讀,在java編程中,主要的變量就是屬性和局部變量,局部變量一般是指在成員方法中定義的變量,局部變量也就是除了屬性之外的其他變量,作用域為定義他的代碼塊中,需要的朋友可以參考下2024-01-01
IDEA 2020.1 搜索不到Chinese (Simplified) Language
小編在安裝中文插件時遇到IDEA 2020.1 搜索不到Chinese ​(Simplified)​ Language Pack EAP,無法安裝的問題，本文給大家分享我的解決方法，感興趣的朋友一起看看吧2020-04-04