Java8的Lambda表达式

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