Java函數(shù)接口和Lambda表達式深入分析

更新時間：2025年04月05日 11:45:32 作者：憶愿

這篇文章主要介紹了Java函數(shù)接口和Lambda表達式,函數(shù)接口是一個具有單個抽象方法的接口,接口設計主要是為了支持Lambda表達式和方法引用,使得Java能更方便地實現(xiàn)函數(shù)式編程風格,需要的朋友可以參考下

一、函數(shù)接口

函數(shù)接口是一個具有單個抽象方法的接口，接口設計主要是為了支持 Lambda 表達式和方法引用，使得 Java 能更方便地實現(xiàn)函數(shù)式編程風格。

特點和用途：

單一抽象方法：函數(shù)接口只能有一個抽象方法，但可以有多個默認方法（default）或靜態(tài)方法（static）。
Lambda 表達式：可以使用函數(shù)接口創(chuàng)建 Lambda 表達式，從而簡潔地表示匿名函數(shù)，例如在集合操作、線程處理等場景中。
方法引用：可以通過函數(shù)接口的類型來引用一個已存在的方法，使代碼更簡潔和可讀性更高。

Java 8 提供了幾個標準的函數(shù)接口，接口通常位于 java.util.function 包中。

常見的函數(shù)接口：

Consumer：接收一個輸入?yún)?shù)并且不返回結(jié)果的操作。

Consumer<String> printConsumer = str -> System.out.println(str);
printConsumer.accept("Hello World!");

Supplier：不接收參數(shù)但是返回結(jié)果的提供型接口。

Supplier<Double> randomSupplier = () -> Math.random();
System.out.println(randomSupplier.get());

Function：接收一個輸入?yún)?shù)，并返回結(jié)果。

Function<Integer, String> intToString = num -> String.valueOf(num);
System.out.println(intToString.apply(123));

Predicate：接收一個輸入?yún)?shù)，并返回一個布爾值結(jié)果。

Predicate<Integer> isEven = num -> num % 2 == 0;
System.out.println(isEven.test(5)); // false

UnaryOperator：繼承自 Function<T, T>，表示一元操作符。

UnaryOperator<Integer> square = num -> num * num;
System.out.println(square.apply(5)); // 25

自定義函數(shù)接口：只需確保接口中只有一個抽象方法即可。

@FunctionalInterface
interface MyFunctionalInterface {
    void myMethod();
    // 允許有默認方法和靜態(tài)方法
    default void anotherMethod() {
        System.out.println("Default method");
    }
}
// 使用自定義的函數(shù)接口
MyFunctionalInterface myFunc = () -> System.out.println("Hello Custom Functional Interface");
myFunc.myMethod();
myFunc.anotherMethod();

二、Lambda表達式簡介

Lambda 表達式可以被視為匿名函數(shù)的一種聲明方式，允許將函數(shù)作為方法參數(shù)傳遞，或者在需要函數(shù)式接口的地方使用。

基本結(jié)構(gòu)：

// parameters：參數(shù)列表，可以為空或非空
// ->：箭頭符號，分隔參數(shù)列表和Lambda表達式的主體
// expression：單行表達式作為 Lambda 主體
(parameters) -> expression

// { statements; }：代碼塊作為 Lambda 主體，可以包含多條語句和返回語句
(parameters) -> { statements; }

表達式的特點：

簡潔性和可讀性： Lambda 表達式使代碼更為簡潔，尤其是在處理函數(shù)式接口時，省去了冗余的語法。
函數(shù)式編程風格： Lambda 表達式支持函數(shù)式編程，可以輕松地進行函數(shù)傳遞、方法引用和流式操作等。
閉包性： Lambda 表達式可以捕獲其周圍的變量，使得函數(shù)式編程中的狀態(tài)管理更加靈活。

案例：通過 Lambda 表達式為 MathOperation 接口的 operation 方法提供了四種不同的實現(xiàn)：加法、減法、乘法和除法。

接口的定義：

interface MathOperation {
    int operation(int a, int b);
}

使用 Lambda 表達式來實現(xiàn)這個接口，以便傳遞不同的數(shù)學運算邏輯：

public class LambdaDemo {
    public static void main(String[] args) {
        // Lambda 表達式實現(xiàn)加法
        MathOperation addition = (int a, int b) -> a + b;
        System.out.println("10 + 5 = " + operate(10, 5, addition));
        // Lambda 表達式實現(xiàn)減法
        MathOperation subtraction = (a, b) -> a - b;
        System.out.println("10 - 5 = " + operate(10, 5, subtraction));
        // Lambda 表達式實現(xiàn)乘法
        MathOperation multiplication = (int a, int b) -> { return a * b; };
        System.out.println("10 * 5 = " + operate(10, 5, multiplication));
        // Lambda 表達式實現(xiàn)除法
        MathOperation division = (a, b) -> a / b;
        System.out.println("10 / 5 = " + operate(10, 5, division));
    }
    private static int operate(int a, int b, MathOperation mathOperation) {
        return mathOperation.operation(a, b);
    }
}

三、Lambda表達式外部參數(shù)

Lambda 表達式有自己特定的作用域規(guī)則，可以捕獲和訪問其周圍的變量，可以隨意引用外部變量，但如果外部變量是在當前作用域聲明的，則一定不可以進行第二次賦值，哪怕是在 lambda 語句之后。

局部變量：Lambda 表達式可以訪問它們所在方法的局部變量，但是這些變量必須是隱式最終或?qū)嶋H上是最終的（final）。這意味著變量一旦賦值后不再改變。Lambda 表達式內(nèi)部不允許修改這些局部變量的值，否則編譯器會報錯。

public class LambdaScopeDemo {
    public static void main(String[] args) {
        int num = 10; // 局部變量
        MathOperation addition = (int a, int b) -> {
            // num = 5; // 錯誤！Lambda 表達式不能修改局部變量的值
            // 這里訪問了局部變量 num
            return a + b + num;
        };
        System.out.println(addition.operation(5, 3));
    }
}

字段：Lambda 表達式可以訪問外部類的字段（成員變量），包括實例字段和靜態(tài)字段。

public class LambdaScopeDemo {
    private static int staticNum; // 靜態(tài)字段
    private int instanceNum; // 實例字段
    public void testLambdaScope() {
        MathOperation addition = (int a, int b) -> {
            // 訪問實例字段和靜態(tài)字段
            int result = a + b + instanceNum + staticNum;
            return result;
        };
        System.out.println(addition.operation(5, 3));
    }
}

接口的默認方法：Lambda 表達式可以訪問接口中定義的默認方法，但不能訪問接口中定義的實例字段。

四、Lambda范例

使用Lambda表達式時，常見的場景包括對集合的遍歷、排序、過濾以及與函數(shù)式接口的結(jié)合使用。

常見的Java 8 Lambda表達式示例：

遍歷集合

public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");
        // 使用 Lambda 表達式遍歷集合
        names.forEach(name -> System.out.println(name));
    }

使用函數(shù)式接口進行計算

參考：二、Lambda表達式簡介

使用函數(shù)式接口進行條件過濾

public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        // 使用 Lambda 表達式過濾偶數(shù)
        System.out.println("偶數(shù):");
        filter(numbers, n -> n % 2 == 0);
        // 使用 Lambda 表達式過濾大于 5 的數(shù)
        System.out.println("大于 5 的數(shù):");
        filter(numbers, n -> n > 5);
    }
    private static void filter(List<Integer> numbers, Predicate<Integer> condition) {
        for (Integer number : numbers) {
            if (condition.test(number)) {
                System.out.print(number + " ");
            }
        }
        System.out.println();
    }

使用Comparator進行集合排序

public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");
        // 使用 Lambda 表達式進行排序（根據(jù)字符串長度）
        names.sort((s1, s2) -> s1.length() - s2.length());
        // 輸出排序后的結(jié)果
        names.forEach(name -> System.out.println(name));
    }

使用 Runnable 執(zhí)行代碼塊

參考：五、Runnable Lambda表達式

五、Runnable Lambda表達式

使用 Lambda 表達式來簡潔地實現(xiàn) Runnable 接口的實例化。Runnable 接口是一個函數(shù)接口，它只包含一個抽象方法 void run()，用于定義一個可以由線程執(zhí)行的任務。

匿名內(nèi)部類（Java 7 及之前）：

Runnable runnable = new Runnable() {
    @Override
    public void run() {
        System.out.println("Running in a separate thread");
    }
};
Thread thread = new Thread(runnable);
thread.start();

Lambda 表達式（Java 8+）：

Runnable runnable = () -> {
    System.out.println("Running in a separate thread");
};
Thread thread = new Thread(runnable);
thread.start();

更簡潔的方式：任務非常簡單，可以進一步簡化，直接將 Lambda 表達式作為參數(shù)傳遞給 Thread 的構(gòu)造函數(shù)：

Thread thread = new Thread(() -> {
    System.out.println("Running in a separate thread");
});
thread.start();

這種方式避免了顯式地聲明 Runnable 變量，使代碼更加緊湊和易讀。

案例：

public static void main(String[] args) {
        // 使用 Lambda 表達式創(chuàng)建一個新的線程
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("線程執(zhí)行：" + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        // 啟動線程
        thread.start();
    }

以上就是Java函數(shù)接口和Lambda表達式深入分析的詳細內(nèi)容，更多關(guān)于Java函數(shù)接口的資料請關(guān)注腳本之家其它相關(guān)文章！

您可能感興趣的文章: