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


失望的双杠_eJN3LI
1 声望0 粉丝

引用和评论

0 条评论