函式式編程（Functional Programming）
首先，我們來了解一個叫做"編程范式"的概念，
什么是"編程范式"呢？簡單來說就是指導我們編程的方法論，是一種教我們如何撰寫代碼、如何組織代碼的"解題"思路，
業界普遍將編程范式劃分為兩大類：指令式和程序式，當然每個大類也可以接著往下細分，下面只列出了一些比較常見的子分類：
- 指令式（Imperative）
- 程序式（Procedural），比如：Fortran、C
- 面向物件（Object Oriented），比如：C++、Java
- 宣告式（Declarative）
- 邏輯式（Logic），比如：Prolog
- 函式式（Functional），比如：Haskell、Erlang
在上面的分類中，有的同學看到 Java 被劃分到了指令式范式的范疇可能會感覺到疑惑，其實指令式范式與宣告式范式之間并沒有絕對的界限，而且大有相互滲透的趨勢，上述的分類也只是一個廣義的劃分，不用太過較真，稍微有個概念就行了，
指令式范式更關注程序，側重于描述"如何去做"，而宣告式范式關注結果，側重于描述"去做什么"，
來看一個 Java 計算階乘的例子：
// 給出明確的演算法實作（指令式）
public int factorialImperative(int n) {
int f = 1;
for (; n > 0; --n) {
f *= n;
}
return f;
}
// 僅僅給出了階乘的遞回定義（宣告式）
public int factorialDeclarative(int n) {
return n == 0 ? 1 : n * factorialDeclarative(n - 1);
}
什么是函式式編程
關于什么是函式式編程貌似也沒有什么官方的定義，我好像也沒有找到什么權威的解釋，參考 wikipedia 以及自己的一些理解大概描述一下吧：
函式式編程是一種宣告式的編程范式（以目標為導向，側重于描述"去做什么"），通過函式運算以及函陣列合的方式構建程式，并且避免使用共享狀態（變數）以及可變物件，
好吧，總結的好像也比較抽象，沒關系，還是有個概念就好，多寫寫多看看就有感覺了，
說說函式式編程中一些常見的概念吧：
- First-class function（一言以蔽之：函式可以賦值給變數）
- High-order function（一言以蔽之：函式可以作為另一個函式的入參或者出參）
- Pure function（一言以蔽之：給定輸入，輸出總是固定的）
- 補充說明，正是因為輸出總是依賴輸入，所以引申出一些其他的概念
- Side Effect Free（沒有副作用的，即不會污染背景關系）
- Reference Transparency（參考透明，即不依賴外部變數）
- Lazy Evaluation（延遲求值，即呼叫的時機就不那么重要了）
- 補充說明，正是因為輸出總是依賴輸入，所以引申出一些其他的概念
- 不可變（這個很好理解，當一切都是不可變，也就不需要考慮鎖競爭了，也不用擔心并發問題了，并行也變得簡單起來）
- 科里化（一種模塊化和重用代碼的技術，說白了其實就是閉包的一種實踐）
- 延遲串列、模式匹配還有結合器等等大家感興趣的話可以自己去谷歌一下
Java 8 的函式式編程
Java 8 對函式式編程的支持
眾所周知 Java 屬于面向物件編程語言，廣義上屬于指令式范式的語言，但是沒必要較真這個范式的分類，或是追求寫出標準的函式式編程風格的代碼，最重要的還是寫出好的代碼，業務價值OK、擴展性OK、維護性OK（當然好代碼可不止這些標準），
下面我們就來看看 Java 為了支持函式式編程，做了哪些努力，
首先，就是引數傳遞，Java 為了實作把函式當做引數來傳遞，引入了一個函式式介面（Functional Inteface）的概念，
函式式介面
簡單來說函式式介面就是只定義一個方法的介面，比如我們經常會用到的 java.lang.Runnable 和 java.util.concurrent.Callable，
但是這樣的定義未免有點單薄，因為只要人為的在介面里多添加一個方法，那么這個介面就不是函式介面了，又或者說某個介面壓根兒就不是函式式介面，但是這個介面也只定義了一個方法，恰巧也符合函式式介面的語意，比如 java.lang.AutoCloseable，這就會給我們使用帶來很多歧義和誤導，
Java 8 提供了 @FunctionalInterface 注解來解決上面提到的問題，跟泛型和 @Override 類似，@FunctionalInterface 也同樣是編譯器來給代碼做約束的，提供安全性的同時也提高了代碼的可讀性（因為顯示的給你標記了嘛），
當然，這個注解也不是必須的，還是舉 java.lang.AutoCloseable 這個例子，像下面的宣告編譯器也并不會報錯，但是這并沒有什么實際意義，這些都是代碼里面的壞味道，切記不可這樣寫：
public static void main(String[] args) throws Exception {
AutoCloseable unscientific = () -> {
System.out.println("不科學的示例...");
};
unscientific.close();
}
在上面的示例代碼中，引入了 Java 8 的一個新的語法特性，你應該注意到了，就是 () -> {}：一個引數塊+一個箭頭+一個代碼塊，這就是 Lamdba 運算式，
Lambda 運算式
Java 8 引入 Lambda 運算式的主要作用就是簡化代碼撰寫，它只是一個語法糖而已，底層還是基于函式介面來實作的，如下面的示例那樣：
// 基于函式介面
Runnable task1 = new Runnable() {
@Override
public void run() {
// business code
}
};
// Lamdba 寫法
Runnable task2 = () -> {
// business code
};
以前，我們只能通過匿名內部類將代碼作為資料（也可以說是行為）來傳遞，寫過匿名內部類的小伙伴都知道，樣板代碼你肯定是躲不開的，可讀性也沒那么友好，而現在，Lambda 運算式給我們提供了一種更加緊湊的傳遞行為的方式，
可以把 Lambda 運算式理解為函式式介面的一個具體實作的實體，Java 8 也允許我們直接以行內的形式直接撰寫函式式介面的抽象實作，而且，還可以把整個運算式直接當成引數進行傳遞，
最簡單的 Lambda 運算式可以用逗號分隔的引數串列、-> 箭頭符號以及陳述句塊：
Arrays.asList("a", "b", "d")
.forEach(e -> System.out.println(e));
Lambda運算式可能會有回傳值，編譯器會根據背景關系推斷回傳值的型別，如果lambda的陳述句塊只有一行，可以省略return關鍵字，
// 傳統的方式
Arrays.asList("a", "d", "c").sort(new Comparator<String>() {
@Override
public int compare(String e1, String e2) {
return e1.compareTo(e2);
}
});
// Lambda 語法
Arrays.asList("a", "d", "c").sort((e1, e2) -> {
int result = e1.compareTo(e2);
return result;
});
// Lambda 語法精簡
Arrays.asList("a", "d", "c").sort((e1, e2) -> e1.compareTo(e2));
關于 Lamdba 再說兩點：
- 對區域變數的限制
我們在使用程序中，常常發現 Lamdba 參考區域變數必須是final的或者說是隱式的final的，這主要是因為實體變數和區域變數背后的實作有一個關鍵不同：實體變數都存盤在堆中，而區域變數則保存在堆疊上，堆是執行緒共享的，而堆疊是執行緒私有的，換句話說，Lambda 運算式參考的是值，而不是變數， - 方法參考
Java 8 還提供了方法應用來進一步簡化代碼的撰寫，就像上個示例中代碼，我們還能進一步簡寫為：// 方法參考 Arrays.asList("a", "b", "d").sort(String::compareTo);
好了，剛剛介紹了 Java 8 的函式式介面還有 Lambda 運算式，可以進入下一個階段了，就是流（Stream），
流（Stream）
舉個電商計算 ROI（投資回報率）的簡單例子，公式如下：
ROI =［（收入－成本）／ 投入 ］＊100
常規操作可能寫成這樣：
multiply(divide(subtract(收入,成本),投入),100)
但如果我們換一種可讀性更高的寫法：
subtract(收入,成本).divide(投入).multiply(100)
是不是立馬眼前一亮！我們知道 . 運算子是 Java 里面的方法呼叫，為了支持上面的這種級聯操作，Java 8 讓每個方法都回傳一個通用的型別，即：Stream，
流有兩個特點
- 流水線（簡單來說就是函式的級聯呼叫，可以類比SQL陳述句）
- 內部迭代（簡單來說就是不需要像集合那樣顯示的處理迭代）
"流水線"這個特點就像剛剛計算ROI公式的那個例子，比較明了，我們來看看內部迭代：
在 Java 8 以前，我們大量的使用集合，對于稍微復雜一些的操作（過濾、分組、排序等組合操作）我們通常需要顯示的撰寫大量的代碼，當然，這也是無法避免的，這又回到文章開頭提到的指令式范式的特點上面了，在沒有宣告式編程語法的支持下，你只能給出具體的演算法實作，這個就不舉例子了，大家應該深有體會，還是舉個簡單的例子吧：
int count=0;
for (Person person : persons) {
if (person.isFrom("江蘇"))){
count++;
}
}
現在 Java 8 引入了流，在流上支持了宣告式的編程風格，一切就都變得豁然開朗起來，語意也更加豐滿起來了：
long count = persons.stream()
.filter(person -> person.isFrom("江蘇"))
.count()
流的惰性求值
- Stream 上的有兩種操作：中間操作和終止操作
- 中間操作仍然回傳 Stream 物件，而終止操作回傳的是具體的結果（或者說歸約，按照給定的規則對流中的元素進行加工，然后輸出到結果中）
- 常見的中間操作：
map、filter、limit - 常見的終止操作：
max、collect、forEach
- Stream 補充說明
- 流的目的在于表達計算，集合講的是資料，而流講的是計算，粗略地說，集合與流之間的差異就在于什么時候進行計算，流就像是一個延遲創建的集合：只有在消費者要求的時候才會計算值
- 從有序集合生成流時會保留原有的順序，由串列生成的流其元素順序與串列一致
- 流操作可以順序執行，也可以并行執行
- 注意，和迭代器類似，流只能消費一次
常用的流操作
map
如果有一個函式可以將一種型別的值轉換成另外一種型別，map 操作就可以使用該函式，將一個流中的值轉換成一個新的流，
List<String> results = Stream.of("a", "c", "c")
.map(String::toUpperCase)
.collect(Collectors.toList());
// output: [A, B, C]
filter
遍歷資料并檢查其中的元素時，可嘗試使用 Stream 中提供的新方法 filter，
List<Integer> results = Stream.of("1", "2", "3")
.map(Integer::parseInt)
.filter(n -> n % 2 == 0)
.collect(Collectors.toList());
// output: [2]
flatMap
flatMap 方法可用 Stream 替換值，然后將多個 Stream 連接成一個 Stream，
List<Integer> results = Stream.of(Arrays.asList(1, 2), Arrays.asList(3, 4))
.flatMap(List::stream)
.collect(Collectors.toList());
// output: [1, 2, 3, 4]
reduce
reduce 操作可以實作從一組值中生成一個值，
int result1 = IntStream.of(1, 2, 3, 4)
.sum();
int result2 = Stream.of(1, 2, 3, 4)
.reduce(0, (acc, element) -> acc + element);
int result3 = Stream.of(1, 2, 3, 4)
.reduce(0, Integer::sum);
// output: 10
Collector
最后，我們來看一看 Collector介面，Stream 介面中定義了一個 <R, A> R collect(Collector<? super T, A, R> collector); 的方法，接收一個 Collector 型別的引數，Collector 顧名思義，就是收集器，就是按照一定的規則，對流進行資料的歸約操作，
剛剛 map、filter 的示例中都用到了 Stream.collect(Collectors.toList()); ：將流中的元素輸出到一個 List 中去，
我們先看一下 Collector 的介面定義：
// 建立新的結果容器
Supplier<A> supplier();
// 將元素添加到結果容器
BiConsumer<A, T> accumulator();
// 合并兩個結果容器
BinaryOperator<A> combiner();
// 對結果容器應用最終轉換
Function<A, R> finisher();
// 定義了收集器的行為（尤其是關于流是否可以并行歸約），以及可以使用哪些優化的提示，
Set<Characteristics> characteristics();
如果我們想把流中的元素歸約到一個 List<Integer> 中，那么首先，你得有一個收集結果的容器：
Supplier<List<Integer>> containerSupplier = ArrayList::new;
然后我們需要一個累加函式，將流中的一個個元素放到結果容器中：
BiConsumer<List<Integer>, Integer> accumulator = List::add;
然后，我們需要告訴編譯器這個流是否可以并行歸約，或是可以做哪些優化：
Set<Collector.Characteristics> characteristics = Collections.unmodifiableSet(EnumSet.of(Collector.Characteristics.IDENTITY_FINISH));
然后如果是在并行的場景下，我們需要將并行的各個部分進行合并，這個時候，就需要一個合并的函式：
BinaryOperator<List<Integer>> combiner = (List<Integer> left, List<Integer> right) -> {
left.addAll(right);
return left;
};
最后，我們需要一個型別轉換的函式，將流中的元素轉換成歸約的目標型別：
Function<Integer, Integer> finisher = (Integer i) -> (Integer) i;
所以整體思路就是動態新建了一個目標集合，然后遍歷這個流，將流中的元素依次添加到目標集合中，如果不考慮并行的情況，其實Collector就是干了這么一件事，如果你要實作自己的收集器，大體上，也就是跟這5個方法打交道了，
當然，Java 已經給我們提供了不少常用的收集器了，用于實作像 join、groupingBy 等常用操作，可以直接看一下 Collectors 的類注釋，官方很貼心的給我們提供了不少示例代碼，
好了，就寫這么多吧，希望對大家有所幫助，
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/275657.html
標籤：Java