Redmi Buds 4開箱簡評：才199還有降噪 可以無腦入
在上個月舉辦的Redmi Note11T Pro系列新機發布會上，除了兩款手機新品之外，Redmi還帶來了兩款TWS真無線藍牙耳機產品，Redmi Buds 4和Redmi Buds 4 Pro，此前我們在Redmi Note11T
自從 Java 8 引入函數式編程后，給很多 Java 程序員帶來了福音，函數式編程是一種專注于使用函數來創建清晰簡潔的代碼的范式，它不像傳統的命令式編程那樣修改數據和維護狀態，而是將函數視為一等公民。這樣就可以將它們分配給變量，作為參數傳遞，并從其他函數返回，這種方法可以使代碼更易于理解和推理。
近年來，函數式編程因其能夠幫助管理復雜性而越來越受歡迎，尤其是在大型應用程序中，它強調不變性，避免副作用，并以更可預測和模塊化的方式處理數據，這樣可以更輕松地測試和維護代碼。
Java 是一種典型的面向對象語言，為什么會在 Java 8 中引入函數式編程特性？主要原因有以下幾點：
在 Java 語言中，函數式編程主要圍繞著以下幾個關鍵概念：
Java 中的函數式編程給開發帶來了許多便利，但同時也有缺點和挑戰，下面整理了一些主要的優缺點：
(1) 提高了代碼的可讀性
由于使用 Lambda 表達式和方法引用，函數代碼往往非常簡潔，從而減少了樣板代碼并簡化了代碼維護。對不可變性的關注（即數據結構在創建后保持不變）有助于減少副作用，并防止因狀態意外更改而導致的錯誤。
(2) 與并發和并行的兼容性
由于函數式編程促進了不可變性，因此操作可以并行運行，而不會出現數據不一致或競爭條件的常見風險，這使得代碼更適合多線程環境。
(3) 模塊化和可重用性
函數式編程還促進了模塊化和可重用性，由于函數是一等公民，我們可以創建小的、可重用的組件，從而產生更簡潔、更易于維護的代碼。
(4) 降低了復雜性
函數式編程中的抽象降低了整體復雜性，使我們能夠專注于基本邏輯，而不必擔心實現細節。
(1) 學習難度大
函數式編程的學習曲線可能很陡峭，特別是對于習慣于面向過程或面向對象編程的人來說，由于高階函數和不變性等概念，我們的思維方式可能要發生顯著的變化。
由于涉及抽象，調試函數代碼也可能具有挑戰性，理解復雜的 Lambda 表達式可能需要更深入地了解函數概念。
(2) 性能開銷
性能開銷是函數式編程的另一個問題，尤其是由于函數式編程中頻繁的對象創建和附加函數調用，這可能會影響資源受限環境中的性能。
(3) 兼容性問題
與舊系統或庫的集成可能會出現兼容性問題，因為它們可能不是為函數式編程設計的，從而導致集成困難。
(4) 靈活性
最后，函數式編程對不可變性和無副作用函數的關注可能會降低在需要可變性或復雜對象操作的場景中的靈活性。
總的來說，雖然函數式編程提供了顯著的好處，如提高可讀性和更容易的并發性，但它也帶來了挑戰，因此我們需要同時考慮這些優缺點，從而更好的把握函數式編程是否適應當前的 Java 應用程序。
Java 是如何定義函數式接口的？
下圖為 @FunctionalInterface 在 JDK中源碼的具體信息：
通過上述源碼，我們可以得到以下信息：
另外，有些接口盡管它沒有 @FunctionalInterface 注解，然而它只有一個抽象方法，因此該接口本質上也是函數式接口，因此 @FunctionalInterface 注解并不是必須的，但是增加該注釋是一種很優雅的行為，因為它提高了代碼的可讀性，強制執行約束，并幫助其他人理解我們的意圖，有助于提高代碼庫的可維護性和一致性。
Java 的函數式接口有很多豐富的使用方式，這里主要從自定義函數式接口和內建函數式接口兩個大方向進行分析。
從上文的講解我們可以知道：Java 的函數式接口本質上只有一個抽象方法。因此，我們可以利用這個特征來設計一個簡單的計算器示例，接收兩個整數入參并返回算術運算的結果。
為了實現這一點，我們定義一個名為 Calculator 的函數接口，并且包含一個 operate() 抽象方法，示例代碼如下：
@FunctionalInterfaceinterface Calculator { int operate(int a, int b);}在上述示例中，Calculator 接口增加了 @FunctionalInterface注解，它清晰地表明 Calculator 是函數式接口，強調它應該只包含一個抽象方法 operate()。
operate() 方法 ，它接受兩個整數入參并返回一個整數結果，通過這個函數接口，我們可以使用 Lambda 表達式創建不同的算術運算，比如加法、減法、乘法和除法，示例代碼如下：
@Testvoid operateTest() { // 使用 Lambda 定義操作 Calculator add = (a, b) -> a + b; // 加法 Calculator subtract = (a, b) -> a - b; // 減法 Calculator multiply = (a, b) -> a * b; // 乘法 Calculator divide = (a, b) -> a / b; // 除法 // 驗證結果 assertEquals(15, add.operate(10, 5)); assertEquals(5, subtract.operate(10, 5)); assertEquals(50, multiply.operate(10, 5)); assertEquals(2, divide.operate(10, 5));}在 operateTest 這個測試方法中，我們首先使用 Calculator 為加減乘除 4個運算定義了 Lambda 表達式，然后使用斷言來驗證 operate() 方法的算術運算結果與預期值是否匹配。
通過這個示例，我們可以使用自定義函數式接口很靈活的定義 Lambda表達式，實現函數式編程。
從 Java 8 開始， 在 java.util.function 包里面提供了很多內置的函數接口，下面列舉了幾個最常見的內置函數式接口以及它們的典型用例和代碼示例：
(1) Predicate<T>
Predicate<T> 表示接受 T 類型的輸入并返回布爾值的函數，通常用于篩選和條件檢查。源碼如下：
@FunctionalInterfacepublic interface Predicate<T> { /** * Evaluates this predicate on the given argument. * * @param t the input argument * @return {@code true} if the input argument matches the predicate, * otherwise {@code false} */ boolean test(T t); // default methods}使用舉例：
如下代碼，Predicate<Integer> 被定義為 isEven，它檢查一個數是否是偶數。然后，我們使用 filter 方法和 isEven 謂詞來篩選出偶數，并將結果收集到一個新的列表中。
import java.util.Arrays;import java.util.List;import java.util.function.Predicate;import java.util.stream.Collectors;public class PredicateExample { public static void main(String[] args) { List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); Predicate<Integer> isEven = n -> n % 2 == 0; List<Integer> evenNumbers = numbers.stream().filter(isEven).collect(Collectors.toList()); System.out.println("Even numbers: " + evenNumbers); }}(2) Function<T, R>
Function<T, R> 表示函數接受 T 類型的輸入并返回 R 類型的結果，通常用于轉換或映射操作。源碼如下：
@FunctionalInterfacepublic interface Function<T, R> { /** * Applies this function to the given argument. * * @param t the function argument * @return the function result */ R apply(T t); // default methods}使用舉例：
如下代碼，Function<Integer, Integer> 被定義為 square，它計算一個整數的平方。我們使用 map 方法和 square 函數將所有整數轉換為它們的平方，并將結果收集到一個新的列表中。
import java.util.Arrays;import java.util.List;import java.util.function.Function;import java.util.stream.Collectors;public class FunctionExample { public static void main(String[] args) { List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); Function<Integer, Integer> square = n -> n * n; List<Integer> squares = numbers.stream().map(square).collect(Collectors.toList()); System.out.println("Squares: " + squares); }}(3) Consumer<T>
Consumer<T> 表示接受 T 類型的輸入并執行操作而不返回結果的函數，非常適合打印或記錄等副作用操作。源碼如下：
@FunctionalInterfacepublic interface Consumer<T> { /** * Performs this operation on the given argument. * @param t the input argument */ void accept(T t); // default methods}使用舉例：
如下代碼，Consumer<String> 被定義為 printName，它打印一個字符串。然后，我們使用 forEach 方法和 printName 消費者對列表中的每個字符串進行打印。
import java.util.Arrays;import java.util.List;import java.util.function.Consumer;public class ConsumerExample { public static void main(String[] args) { List<String> names = Arrays.asList("Tom", "Bob", "Cherry"); Consumer<String> printName = name -> System.out.println(name); names.forEach(printName); }}(4) Supplier<T>
Supplier<T> 表示該函數提供 T 類型的值而不采用任何參數，對于延遲初始化和延遲計算很有用。源碼如下：
@FunctionalInterfacepublic interface Supplier<T> { /** * Gets a result. * @return a result */ T get(); // default methods}使用舉例：
如下代碼，Supplier<Double> 被定義為 randomSupplier，它返回一個隨機數，我們使用 get 方法來調用供應商并獲取隨機數。
import java.util.function.Supplier;import java.util.Random;public class SupplierExample { public static void main(String[] args) { Supplier<Double> randomSupplier = () -> new Random().nextDouble(); System.out.println("Random number: " + randomSupplier.get()); System.out.println("Random number: " + randomSupplier.get()); }}(5) BiFunction<T,T,T>
BinaryOperator<T, T, T>，表示該函數接受兩個 T 類型的輸入并返回相同類型的結果，可用于組合或減少操作。源碼如下：
@FunctionalInterfacepublic interface BiFunction<T, U, R> { /** * Applies this function to the given arguments. * * @param t the first function argument * @param u the second function argument * @return the function result */ R apply(T t, U u); // default methods}@FunctionalInterfacepublic interface BinaryOperator<T> extends BiFunction<T,T,T> { }使用舉例：
如下代碼，BinaryOperator<Integer> 被定義為將兩個整數相加。我們使用 apply() 方法來調用操作符并獲取結果。源碼如下：
import java.util.function.BinaryOperator;public class BinaryOperatorExample { public static void main(String[] args) { BinaryOperator<Integer> add = (a, b) -> a + b; int result = add.apply(3, 5); System.out.println("Result: " + result); // 輸出: Result: 8 }}Java 8 中的這些內置函數接口為函數式編程奠定了基礎，使我們能夠使用 Lambda 表達式并簡化代碼。由于它們的多功能性，我們可以將它們用于廣泛的應用，從數據轉換到過濾等等。
Lambda 表達式是 Java 8 的一個關鍵特性，它允許我們以清晰簡潔的方式創建緊湊的匿名函數，提供了一種以更簡單的形式表示函數式接口的方法，因此，Lambda 表達式是 Java 函數式編程的基石。
Lambda 表達式的一般語法如下：
() -> {}Lambda 包含三個部分：
主體只有一條語句的 Lambda 表達式示例：
Function<String, String> toUpper = s -> s == null ? null : s.toUpperCase();上述示例中，因為只有一個參數，所以 () 被省略了，因為主體只有一語句，所以 {} 被省略了。
主體包含多條語句的 Lambda 表達式示例：
IntToLongFunction factorial = n -> { int result = 0L; for (int i = 0; i <= n; i++) { result += i; } return result; };上述示例中，因為只有一個參數，所以 () 被省略了，因為主體包含多條語句，所以 {} 不能被省略。
上述兩個示例，使用 Lambda 表達式來創建匿名函數，這使得我們能夠編寫內聯邏輯，而無需額外的類定義。我們可以在需要我們傳遞函數接口的地方使用這種匿名函數。
本文，我們將通過 Lambda 表達式的 Java 代碼和 JVM 字節碼的對比來探究 Lambda的內部工作原理。
在 Java 中，我們有兩種類型的值：原生類型和對象引用，而 Lambda 顯然不是原生類型，它實際上是一種返回對象引用的特殊表達式，有人把它叫傳函數。
接下來，我們用 LambdaTest 測試類來對 num 進行加倍操作，并查看其字節碼作為演示，示例代碼如下：
public class LambdaTest { LongFunction<Long> doubleNum = num -> 2 * num;}使用 javap -c -p 指令編譯其字節碼，指令如下：
javap -c -p LambdaTest.class指令執行結果如下：
Compiled from "LambdaTest.java"public class com.yuanjava.LambdaTest { java.util.function.LongFunction<java.lang.Long> doubleNum; public com.yuanjava.LambdaTest(); Code: 0: aload_0 1: invokespecial #1 // Method java/lang/Object."<init>":()V 4: aload_0 5: invokedynamic #2, 0 // InvokeDynamic #0:apply:()Ljava/util/function/LongFunction; 10: putfield #3 // Field doubleNum:Ljava/util/function/LongFunction; 13: return private static java.lang.Long lambda$new$0(long); Code: 0: ldc2_w #4 // long 2l 3: lload_0 4: lmul 5: invokestatic #6 // Method java/lang/Long.valueOf:(J)Ljava/lang/Long; 8: areturn}從上面的字節碼可以看出它是以invokedynamic 調用開頭，整個過程分析如下：
(1) 編譯：Java 編譯器并沒有為 Lambda 生成新的匿名內部類，而是使用了 Java 7 中引入的 invokedynamic 技術；
(2) InvokeDynamic：invokedynamic 指令支持 JVM 上的動態語言，它可以將 JVM 對 Lambda 實例的創建推遲到運行階段，與傳統的匿名內部類相比，這提供了更大的靈活性和效率。
(3) Lambda Metafactory：當 JVM 在運行時遇到 invokedynamic 指令，它會調用一個名為 LambdaMetafactory.metafactory() 的特殊方法，此方法負責創建 Lambda 表達式的實際實現。JVM 會使用此元工廠方法生成表示 Lambda 的輕量級類或方法句柄。
(4) 創建實例：LambdaMetafactory 會動態創建 Lambda 表達式的實例：
(5) 運行：運行 Lambda 表達式，就如同實現函數接口的匿名內部類的實例一樣，JVM 會確保 Lambda 符合預期函數接口的單一抽象方法。
上文，我們分析了函數式接口以及 Lambda，那么兩者存在什么關系呢？
在編程語言中，lambda 表達式和函數式接口通常在一起使用，尤其在支持函數式編程的語言中（比如 Java 和 Python）。它們之間的關系可以通過以下幾點來理解：
總結來說，Lambda 表達式提供了一種簡潔的方法來定義匿名函數，而函數式接口提供了一種目標類型，使得這些匿名函數可以被類型安全地傳遞和使用，兩者的結合在現代編程中極大地促進了函數式編程的應用。
在本文中，我們學習了什么是函數式接口以及如何定義函數式接口，接著我們分析了 lambda 表達式及其內部工作原理。
函數式編程和 lambda 表達式可以為我們的代碼帶來新的優雅和效率，所以建議日常開發中可以多多實操，享受它給我們帶來的便捷。
本文鏈接：http://www.www897cc.com/showinfo-26-101716-0.htmlJava 函數式接口，一文徹底剖析！
聲明：本網頁內容旨在傳播知識，若有侵權等問題請及時與本網聯系，我們將在第一時間刪除處理。郵件：2376512515@qq.com
Copyright ? 2016-2023 天津谷騏科技有限公司 版權所有 sitemap.xml
違法及侵權請聯系：2376512515@qq.com 津ICP備18001702號
津公網安備 12010102000574號