什么是函式式編程
函式不同于OOP中的方法，可以理解成數學中的函式，是一種將輸入集與輸出集關聯的運算式，和命令式編程不同，函式式編程只取決于它的輸入，不依賴于函式外狀態，
編程范式的分類: 編程范式可以分為命令式和宣告式，
- 命令式將程式定義為一系列陳述句，通過陳述句改變程式的狀態，最終達到最終的狀態，面向狀態編程，OOP是命令式范式的擴展，
- 宣告式范式專注于“程式要實作什么”，而不是“程式如何實作”，面向行為編程，函式式編程是宣告式編程的子集，
函式式核心概念
Haskell是純函式式語言，入門曲線高，使用范圍小，當今大多數流行語言都是支持多種編程方式的，例如java、Scala、Kotlin，以下結合java舉例，
函式是一等值
如果一種編程語言將函式視為一等公民，那么它就被稱為具有一等函式，這意味著函式支持其他一等值都具有的操作: 賦值給變數、作為引數傳遞、動態生成、作為其他函式回傳值回傳等，
static <T> Function<T, T> compose(Supplier<T> supplier, Function<T, T> map) { // 做引數，做回傳值
return data -> map.apply(supplier.get()); // 動態生成
}
高階函式
將函式看做一等值，等價于語言中值的存在，就很自然的想能不能寫一個函式，實作一些傳入函式，回傳一個函式? 這就是高階函式，上文的示例其實就是一個高階函式，
高階函式也叫復合函式，在java中通常通過函式式介面的default方法來實作的，例如Function的java.util.function.Function#compose和java.util.function.Function#andThen，當然也可以自己實作函式的復合，
default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
return (V v) -> apply(before.apply(v));
}
在java中，Stream的使用(Optional不是)近似于高階函式，如下代碼所示，
@Test
public void test_Stream() {
Stream<Integer> stream = Stream.of(1).map(i -> {
System.out.println(i);
return 1;
});
// 不會輸出1
}
純函式
純函式是沒有狀態的、無副作用的，可以簡單的認為: 你搞幾次都是沒有關系的~
這和OOP沖突，面向物件鼓勵我們將物件的狀態隱藏，只公開訪問和修改物件的必要方法，甚至，將資料存盤到資料庫中，對于純函式而言也是“有副作用”的，更有甚者，連打日志都認為是一種副作用，
在實際生產中，我們要有自己的界限與衡量標準，不是“純”的就一定是好的、是先進的，
此外，純函式通常認為是不應該拋出任何例外的，
不可變性
不變性是函式式編程的核心原則之一，例如Clojure，默認上變數是不可變的，如果你要改變變數，你需要把變數copy出去修改，這對于并行程式來說，bug會大大減少，java中可以通過final來實作，
不可變的資料結構所有欄位都是不可變的，其嵌套資料結構也要滿足不可變性，除建構式外應該沒有其他的set方法，
Referential Transparency 透明參考
函式的回傳值只依賴于其輸入值，這種特性就稱為參考透明性（referential transparency）
如果將運算式替換為其相應的值對程式的行為沒有影響，那么我們稱之為參考透明，這需要函式是純粹的、不可變的，它產生了一個與背景關系無關的代碼塊，可以在任意地方、以任意順序執行，這提供了許多優化的可能性，
尾遞回優化
迭代呼叫發生在函式的最后，因此不需要沒深入呼叫一層就新建一個堆疊，
需要編譯器支持，目前java還不支持，Scala和Groovy都已經支持了，本質上就是通過重用堆疊的方式來優化遞回的性能損耗，
Monads
一個自函子范疇上的幺半群，
這個解釋太費腦了，摘自阮一峰的解釋更容易理解些: Monad就是一種設計模式，表示將一個運算程序，通過函式拆解成互相連接的多個步驟，
再簡單點理解: 利用map、reduce、predict等方式的流式編程，
在java中，Monads可以具象成Optional、Stream、CompletableFuture等，比如Optional 可以包裝一個值并應用一系列轉換，例如使用 flatMap添加另一個包裝值的轉換，
Currying 科里
在傳遞函式時，該函式是攜帶引數進行傳遞的，
區域套用是一種數學技巧，它將一個接受多個引數的函式轉換成一個接受單個引數的函式序列，在這種技術中，可以不需要呼叫一個函式的所有引數，
以下舉一個例子說明:
// 根據入參mass來獲得一個Function，該Function輸入gravity，輸出mass * gravity
Function<Double, Function<Double, Double>> weight = mass -> (gravity -> mass * gravity);
// 地球上的重力函式
Double, Double> weightOnEarth = weight.apply(9.81);
logger.log(Level.INFO, "在地球上我的體重為" + weightOnEarth.apply(60.0));
// 火星上的重力函式
Function<Double, Double> weightOnMars = weight.apply(3.75);
logger.log(Level.INFO, "在火星上我的體重為: " + weightOnMars.apply(60.0));
如果不用Currying，可能在計算重力時還要再傳入一個mass引數，
Currying 依賴于語言來提供兩個基本特性: lambda 運算式和閉包，
和其他語言不同，java8中的閉包要求lambda運算式中的變數必須是final修飾的或實際上是final的，這是出于執行緒安全的考慮，
為什么要學習函式式編程
更高效的支持并發
函式式編程要求，只使用運算式，不使用陳述句，也就是說，每一步都是單純的運算，而且都有回傳值，根據前文中的“純函式”定義和“透明參考”的定義，可以知道任意執行順序時是不會影響最終的結果，
因此，在并發環境下，函式式編程撰寫安全、高性能的代碼更為容易，
代碼簡潔、復用度高
函式式編程大量使用函式，減少了代碼的重復，因此程式比較短，開發速度較快，
設計良好的函式式編程不會
代碼易于測驗、易于管理
設計良好的函式式編程不依賴于外界狀態、輸入輸出保持一致，這很利于“單元測驗”的進行，
java對函式式的支持
java8提供了lambda運算式、方法參考、預定義函式介面來適配函式式編程，
java將lambda運算式看做函式式介面的物件實體，但這在設計層面上就已經滿足一等值的概念了，
函式式介面
jdk已經提供了一系列的函式式介面(Package java.util.function)了，例如Consumer、Supplier、Function、Predicate以及其他的出于拆箱裝箱性能損耗的DoubleConsumer、IntPredicate，和基于多引數的BiConsumer等，
如果function包下的介面還不能滿足你的需求，可以配合桑除蟲@FunctionalInterface宣告自己的函式式介面，對于函式式介面而言，@FunctionalInterface其實是可加可不加的，它的作用是在編譯時看看你的函式式介面是否只有一個實體方法，
因為在java中，是通過實體化函式式介面的方式(常基于lambda運算式)來進行函式式支持的，
// 自定義消費int的函式式介面
@FunctionalInterface
interface consumeInt {
void consume(int i);
}
// 實體化函式式介面
consumeInt consumeInt = i -> System.out.println(i);
lambda運算式
lambda運算式的語法很簡單:
(parameters) -> expression // 若只有一條執行陳述句的話不帶{}
或
(parameters) ->{ statements; } // 多條執行陳述句帶{}，且帶;
lambda運算式會自動推斷引數的型別，一般來說是依賴于函式式介面指定的引數型別，但配合java范型的使用使lambda運算式擁有更為豐富的表達能力:
Function<String, String> function = str -> // 使用范型指定傳入String 傳出String
new StringBuilder(str).append("-").append(str.length()).toString();
// 當然也可以手動指定型別
Function<String, String> function = (String str)->...
方法參考
參考文章
方法參考可以分為四類: 指向靜態方法的、指向lambda運算式中變數的實體方法的、指向外部物件的實體方法的、建構式的，
在java中方法的宣告包括6個方面:修飾符、回傳值、方法名、方法引數、例外串列、方法體，使用方法參考時:
- 修飾符要復合條件(訪問不到的方法自然方法參考也不可用)
- 確保方法簽名的匹配( 方法簽名包含回傳值和方法引數)
- 確保例外串列的兼容，(要求被參考的方法比需要的方法例外串列更小)
public class FunctionRefSt {
// 靜態方法
public static int length(String str) {
return str.length();
}
// 實體方法
public int lengthIns(String str) {
return str.length();
}
// 四種參考的展示
@Test
public void funcRef() {
Optional<String> opt = Optional.of("hello world");
/*以下三種輸出都是11*/
// 靜態方法參考
opt.map(FunctionRefSt::length).ifPresent(System.out::println);
// 內部實體方法參考
opt.map(String::length).ifPresent(System.out::println);
// 外部實體方法參考
FunctionRefSt functionRefSt = new FunctionRefSt();
opt.map(functionRefSt::lengthIns).ifPresent(System.out::println);
/*建構式參考實體*/
// 利用optional避免空指標
System.out.println(Optional.<List>ofNullable(null).orElseGet(/*參考了構造方法*/ArrayList::new).size());
//輸出0
}
}
模式匹配
模式匹配可以簡單的理解成增強switch運算式，java8目前還不支持模式匹配，其switch能支持的匹配型別還是比較少的: 列舉、String、byte、short、int、char以及一些基本型別的包裝類，在java12之后，switch運算式進行了一番的優化，jdk13switch特性:
// jdk12
switch (type) {
case "all" -> System.out.println("列出所有帖子");
case "auditing" -> System.out.println("列出審核中的帖子");
case "accepted" -> System.out.println("列出審核通過的帖子");
case "rejected" -> System.out.println("列出審核不通過的帖子");
default -> System.out.println("引數'type'錯誤，請檢查");
}
// jdk13
String value = switch (i) {
case 0 -> "zero"
case 1 -> "one"
case 2 -> "two"
default -> "many"
};
System.out.println(value);
總結
在java中函式式編程有兩大核心利器: Optional和Stream，
關于Optional的更多學習鏈接可以看看這個文章哦: 你真的知道Optional怎么使用嗎?
例外:一般來說，函式是處理不了例外的，而且設計良好的函式是可以預計到所有的例外，并有一個合適的輸出，所以對于例外情況可以定義一些特殊值來處理: 比如Optional.empty()，
副作用可以是日志、存盤到DB、更新快取、RPC呼叫等等，編碼是絕對離不開副作用的，name怎么處理副作用呢?
一般來說，處理副作用有兩種方法，但是核心都是抽取有副作用的代碼和沒有副作用的代碼，將他們隔離開來，
他們有兩個專業術語: 1. Functor函子(在java中使用Stream、Optional來實作) 2. 將可變部分抽取出來，
最后，java8只是提供了函式式編程的一些語法糖，至于是否能用到函式式編程提供的優點，還需要滿足一系列的“函式式編程要求”哦，
相關鏈接
- Package java.util.function
- Functional Programming in Java
各位保種身體，注意頭發，告辭!
轉載請註明出處，本文鏈接：https://www.uj5u.com/ruanti/249099.html
標籤：其他