Java中的Lambda表達式是Java 8引入的一種新特性，主要用於簡化代碼，特別是在處理函數式編程和集合操作時。Lambda表達式允許你將功能作為方法參數傳遞，使代碼更加簡潔和易讀。

1.基本語法

Lambda 的格式由3個部分組成

其標準格式為：
(參數類型 參數名稱 …) -> { 代碼語句 }

1. 多個參數 小括號內的語法與傳統方法參數列表一致：無參數則留空；多個參數則用逗號分隔。
2. 一個箭頭 -> 是新引入的語法格式，代表指向動作。
3. 一段代碼 大括號內的語法與傳統方法體要求基本一致。實現的為代碼邏輯部分，可以是一行代碼也可以是一個代碼片段

案例1：使用Lambda表達式實現Runnable接口

public class LambdaDemo1 {
    public static void main(String[] args) {
        // 使用匿名類 傳統寫法  
        Runnable runnable1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("我是1!");
            }
        };

        // 使用Lambda表達式
        Runnable runnable2 = () -> System.out.println("我是2!");

        // 執行Runnable
        runnable1.run();
        runnable2.run();
    }
}

案例2：使用Lambda表達式遍歷集合

public class LambdaDemo2 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("Java");
        list.add("Python");
        list.add("C++");

        // 使用Lambda表達式遍歷集合
        list.forEach(item -> System.out.println(item));

        // 或者更簡潔的方式
        list.forEach(System.out::println);
    }
}

案例3：使用Lambda表達式實現Comparator接口

public class LambdaDemo3 {
    public static void main(String[] args) {
        String[] names = {"AAA", "BBB", "CCC", "DDD"};

        // 使用匿名類
        Arrays.sort(names, new Comparator<String>() {
            @Override
            public int compare(String a, String b) {
                return b.compareTo(a);
            }
        });

        // 使用Lambda表達式（省略類型參數）
        Arrays.sort(names, (a, b) -> b.compareTo(a));

        // 進一步簡化，使用 Comparator.reverseOrder()
        Arrays.sort(names, Comparator.reverseOrder());

        // 輸出排序結果
        for (String name : names) {
            System.out.println(name);
        }
    }
}

案例4：使用Lambda表達式進行集合過濾和映射

public class LambdaDemo4 {
    public static void main(String[] args) {
        List<String> stringList = Arrays.asList("AAA", "B", "CCC", "D");

        // 過濾長度大於2的字符串
        List<String> filtered = stringList.stream()
                .filter(s -> s.length() > 2)
                .collect(Collectors.toList());

        // 映射為大寫
        List<String> upperCased = stringList.stream()
                .map(String::toUpperCase)
                .collect(Collectors.toList());

        // 輸出結果
        filtered.forEach(System.out::println);
        upperCased.forEach(System.out::println);
    }
}

案例5：使用Lambda表達式實現自定義函數式接口

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

public class LambdaDemo5 {
    public static void main(String[] args) {
        // 定義加法操作
        MathOperation addition = (a, b) -> a + b;

        // 定義減法操作
        MathOperation subtraction = (a, b) -> a - b;

        // 使用自定義的函數式接口
        System.out.println("10 + 5 = " + operate(10, 5, addition));
        System.out.println("10 - 5 = " + operate(10, 5, subtraction));
    }

    private static int operate(int a, int b, MathOperation mathOperation) {
        return mathOperation.operation(a, b);
    }
}

案例1中的Runnable

Runnable是Java中一個非常重要的接口，用於定義一個任務，該任務可以在線程中執行。Runnable接口只有一個抽象方法：

public interface Runnable {
    void run();
}

實現Runnable接口的類需要提供run方法的具體實現，這個方法會包含任務的具體邏輯。Runnable接口常與Thread類一起使用，以便在一個新的線程中執行任務。

使用Runnable的基本步驟

1. 實現Runnable接口：創建一個類並實現Runnable接口，提供run方法的實現。
2. 創建Thread對象：將實現了Runnable接口的對象傳遞給Thread對象的構造方法。

3. 啓動線程：調用Thread對象的start方法，啓動新的線程並執行run方法中的代碼。

   示例：使用Runnable接口創建並啓動一個線程

   下面是一個簡單的例子，展示如何使用Runnable接口創建並啓動一個線程：

   class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Hello from a thread!");
    }
   }
   
   public class RunnableExample {
    public static void main(String[] args) {
        // 創建一個Runnable實例
        Runnable myRunnable = new MyRunnable();
   
        // 將Runnable實例傳遞給Thread構造器
        Thread thread = new Thread(myRunnable);
   
        // 啓動線程
        thread.start();
   
        // 主線程的輸出
        System.out.println("Hello from the main thread!");
    }
   }

   在這個例子中，MyRunnable類實現了Runnable接口並提供了run方法的實現。在main方法中，創建了一個MyRunnable實例，並將其傳遞給Thread構造方法，然後調用start方法啓動新線程，執行run方法中的代碼。

使用Lambda表達式實現Runnable

Java 8引入了Lambda表達式，使得實現Runnable接口變得更加簡潔。可以直接用Lambda表達式代替匿名類來創建Runnable對象：

public class LambdaRunnableExample {
    public static void main(String[] args) {
        // 使用Lambda表達式實現Runnable接口
        Runnable myRunnable = () -> System.out.println("Hello from a thread!");

        // 將Runnable實例傳遞給Thread構造器
        Thread thread = new Thread(myRunnable);

        // 啓動線程
        thread.start();

        // 主線程的輸出
        System.out.println("Hello from the main thread!");
    }
}

在這個例子中，Lambda表達式()-> System.out.println("Hello from a thread!")實現了Runnable接口的run方法，使代碼更加簡潔和易讀。

Runnable接口的常見用途

1. 並行執行任務：通過將不同的任務放入不同的線程中執行，實現並行處理。
2. 定時任務：配合定時器，可以定期執行某些任務。
3. 後台任務：在後台執行不需要立即返回結果的任務，例如文件下載、數據備份等。

Runnable接口是Java併發編程中的一個基礎接口，定義了一個可以在線程中執行的任務。通過實現Runnable接口，可以將任務邏輯與線程管理分離，使得代碼更加清晰和可維護。

轉載自開思通智網：https://www.opensnn.com/os/article/10000881