Java中的七種函數式編程技巧
環境：Java21
1. 簡介
函數式編程是一種編程范式，以函數為核心，避免改變狀態與可變數據，強調函數的第一公民地位。它通過使用高階函數和純函數，實現代碼的模塊化和重用性，提升可讀性和可維護性，常用于并發編程和數學計算等領域。
在函數式編程中，有兩條非常重要的規則：
- 無數據變異
這意味著一旦數據對象被創建后就不應該再被更改。任何對該對象的操作都應該返回一個新的對象，而不是修改原始對象。 - 無隱式狀態
應避免隱藏或隱式狀態。這樣理解：在傳統編程中，一個函數可能依賴于一些外部或隱藏的狀態，比如全局變量、靜態變量或者類成員變量等，這些狀態不是通過參數傳遞給函數的。在函數式編程中，提倡避免這種隱式的依賴關系，而是將所有需要的狀態都作為參數顯式地傳遞給函數。這樣做的結果是提高了代碼的透明度和可測試性，因為你清楚地知道函數依賴哪些輸入來產生輸出，同時也減少了副作用的發生，即函數執行時除了返回值外不改變其他任何東西。
除了上述內容外，還有以下可以在Java中應用的函數式編程概念：
- 高階函數（Higher-order functions）
- 閉包（Closures）
- 柯里化（Currying）
- 遞歸（Recursion）
- 惰性求值（Lazy evaluations）
- 引用透明性（Referential transparency）
使用函數式編程并不意味著必須全盤采用，你可以始終使用函數式編程概念來補充面向對象的概念，尤其是在Java中。無論你使用的范式或語言是什么，都可以盡可能地利用函數式編程的優點。
接下來，我們將詳細介紹函數式編程在Java中的應用
2. 實戰案例
2.1 一等函數和高階函數
在一等函數的上下文中，函數被視為頭等公民，意味著它們可以被賦值給變量、作為參數傳遞給其他函數、從函數中返回，以及包含在數據結構中。遺憾的是，Java并不完全支持這一特性，因此像閉包、柯里化和高階函數這樣的概念在Java中實現起來不如在其他語言中那么方便。
在Java中最接近一等函數的概念是Lambda表達式。此外，在java.util.function包下還有一些內置的函數式接口，如Function、Consumer、Predicate、Supplier等，可以用于函數式編程。
只有當一個函數接受一個或多個函數作為參數，或者返回另一個函數作為結果時，它才能被視為高階函數。在Java中，我們最接近高階函數的方式是使用Lambda表達式和內置的函數式接口。
public class Test {
public static void main(String[] args) {
var list = Arrays.asList("Orange", "Apple", "Banana", "Grape", "XPack", "AKF");
var ret = calcLength(list, new FnFactory<String, Object>() {
public Object execute(final String it) {
return it.length();
}
});
System.err.printf("Length: %s%n", ret);
}
static <T, S> ArrayList<S> calcLength(List<T> arr, FnFactory<T, S> fn) {
var list = new ArrayList<S>();
arr.forEach(t -> list.add(fn.execute(t)));
return list;
}
@FunctionalInterface
public interface FnFactory<T, S> {
S execute(T it);
}輸出結果：
Length: [6, 5, 6, 5, 5, 3]接下來，我們使用內置的Function接口和Lambda表達式語法來簡化上面的示例：
public class Test1 {
public static void main(String[] args) {
var list = Arrays.asList("Orange", "Apple", "Banana", "Grape", "XPack", "AKF") ;
var ret = calcLength(list, it -> it.length()) ;
System.err.printf("Length: %s%n", ret) ;
}
static <T, S> ArrayList<S> calcLength(List<T> arr, Function<T, S> fn) {
var list = new ArrayList<S>() ;
arr.forEach(t -> list.add(fn.apply(t))) ;
return list ;
}
}使用這些概念加上Lambda表達式，我們可以像下面這樣編寫閉包和柯里化。
public class ClosureTest {
Function<Integer, Integer> add(final int x) {
Function<Integer, Integer> add(final int x) {
// 普通寫法
// var partial = new Function<Integer, Integer>() {
// public Integer apply(Integer y) {
// return x + y;
// }
// };
// 使用Lambda表達式語法；注意這里不能使用var
Function<Integer, Integer> partial = y -> x + y ;
return partial;
}
return partial;
}
public static void main(String[] args) {
ClosureTest closure = new ClosureTest();
var c1 = closure.add(100) ;
var c2 = closure.add(200) ;
System.out.println(c1.apply(66));
System.out.println(c2.apply(66));
}
}運行結果
166
266以上是關于閉包的應用。
Java中也有許多內置的高階函數，如java.util.Collections#sort方法：
public static void main(String[] args) {
var list = Arrays.asList("Apple", "Orange", "Banana", "Grape");
Collections.sort(list, (String a, String b) -> {
return a.compareTo(b);
});
System.err.printf("%s%n", list) ;
}Java Stream相關API中也提供了許多高階函數，比如forEach、map等。
2.2 純函數
函數式編程傾向于使用遞歸而不是循環。在Java中，這可以通過使用流API或編寫遞歸函數來實現。讓我們來看一個計算數字階乘的例子。還使用JMH對這些方法進行了基準測試，并在下方列出了每操作的納秒數。
在傳統的迭代方法中：
@State(Scope.Thread)
public class FactorialTest {
// 我們要使用JMH進行測試，所以通過@Param定義入參
@Param({"20"})
private long num ;
@Benchmark
public long factorial() {
long result = 1;
for (; num > 0; num--) {
result *= num;
}
return result;
}
public static void main(String[] args) throws Exception {
Options options = new OptionsBuilder()
.include(FactorialTest.class.getSimpleName())
.forks(1)
.build() ;
new Runner(options).run() ;
}
}測試結果
Benchmark (num) Mode Cnt Score Error Units
FactorialTest.factorial 20 avgt 5 0.475 ± 0.013 ns/op同樣的功能也可以使用遞歸來實現，如下所示，這在函數式編程中更為青睞。
@State(Scope.Thread)
public class FactorialTest2 {
@Param({ "20" })
private long num;
@Benchmark
public long factorialRec() {
return factorial(num);
}
private long factorial(long n) {
return n == 1 ? 1 : n * factorial(n - 1);
}
public static void main(String[] args) throws Exception {
Options options = new OptionsBuilder()
.include(FactorialTest2.class.getSimpleName())
.forks(1)
.build();
new Runner(options).run();
}
}測試結果
Benchmark (num) Mode Cnt Score Error Units
FactorialTest2.factorialRec 20 avgt 5 17.316 ± 0.792 ns/op遞歸方法的缺點是，它通常會比迭代方法更慢（我們追求的優勢在于代碼的簡潔性和可讀性），并且由于每次函數調用都需要作為棧幀保存到堆棧中，可能會導致棧溢出錯誤。
我們還可以使用Stream進行遞歸調用
@Param({ "20" })
private long num;
@Benchmark
public long factorialRec() {
return LongStream.rangeClosed(1, num)
.reduce(1, (n1, n2) -> n1 * n2);
}運行結果
Benchmark (num) Mode Cnt Score Error Units
FactorialTest2.factorialRec 20 avgt 5 17.618 ± 1.414 ns/op與遞歸算法差不多。
在編寫Java代碼時，考慮到可讀性和不可變性，可以考慮使用流API或遞歸；但如果性能至關重要，或者迭代次數將非常大，則應使用標準循環。
2.3 惰性求值（Lazy evaluations）
惰性求值（Lazy evaluation）或非嚴格求值是指推遲表達式的計算，直到其結果真正被需要時才進行計算。一般來說，Java執行的是嚴格求值，但對于像&&、||和?:這樣的運算符，它會進行惰性求值。我們可以利用這一點在編寫Java代碼時實現惰性求值。
考慮下面這個例子，在這個例子中Java會急切地（eagerly）計算所有內容：
public static void main(String[] args) {
System.out.println(addOrMultiply(true, add(4), multiply(4))); // 8
System.out.println(addOrMultiply(false, add(4), multiply(4))); // 16
}
public static int add(int x) {
System.out.println("executing add");
return x + x;
}
public static int multiply(int x) {
System.out.println("executing multiply");
return x * x;
}
public static int addOrMultiply(boolean add, int onAdd, int onMultiply) {
return (add) ? onAdd : onMultiply;
}執行結果
executing add
executing multiply
8
executing add
executing multiply
16函數一早就被執行了。
我們可以使用Lambda表達式和高階函數將此重寫為惰性求值的版本：
public static void main(String[] args) {
UnaryOperator<Integer> add = t -> {
System.out.println("executing add");
return t + t;
};
UnaryOperator<Integer> multiply = t -> {
System.out.println("executing multiply");
return t * t;
};
System.out.println(addOrMultiply(true, add, multiply, 4));
System.out.println(addOrMultiply(false, add, multiply, 4));
}
public static <T, R> R addOrMultiply(
boolean add, Function<T, R> onAdd,
Function<T, R> onMultiply, T t) {
return (add ? onAdd.apply(t) : onMultiply.apply(t));
}執行結果
executing add
8
executing multiply
16我們可以看到只執行了所需的功能。
2.4 引用透明性（Referential transparency）
表示在程序中，一個函數調用可以用它的返回值來替換，而不改變程序的行為。換句話說，對于相同的輸入，函數總是產生相同的結果，沒有副作用。
遺憾的是，在Java中限制數據變異的方法并不多。然而，通過使用純函數，并明確避免數據變異和重新賦值（使用我們之前討論過的其他概念），可以實現這一目標。對于變量，我們可以使用final關鍵字，它是一個非訪問修飾符，用于防止通過重新賦值來改變變量的值。
例如，下面的代碼將在編譯時產生錯誤：
final var list = Arrays.asList("Apple", "Orange") ;
// 你不能重新賦值
list = Arrays.asList("Pack", "XXXOOO") ;但是，當變量持有對其他對象的引用時，這并不會起到作用。例如，即使使用了final關鍵字，下面的對象變異仍然會發生：
final var list = new ArrayList<>() ;
// 我們還是可以添加數據
list.add("XXX") ;
list.add("OOO") ;final 關鍵字允許引用變量的內部狀態被修改，因此從函數式編程的角度來看，final 關鍵字僅對常量和捕獲重新賦值有用。
