Java学习教程，从入门到精通，Java Lambda 表达式语法知识点及案例代码（79）

Java Lambda 表达式语法知识点及案例代码

Lambda表达式 是Java 8引入的一项重要特性，它允许我们将代码当作数据来传递，从而使代码更加简洁和易读。

1. 什么是Lambda表达式？

Lambda表达式是一种匿名函数，它没有类和方法名，可以直接作为参数传递给方法或存储在变量中。

2. Lambda表达式的语法结构

Lambda表达式的语法结构如下：

(参数列表) -> {  
    // 方法体
}

• 参数列表：包含方法的参数，可以有多个参数，用逗号分隔。
• 箭头符号->：将参数列表与方法体分隔开。
• 方法体：包含要执行的代码，可以是单行或多行。

注意：

• 如果方法体只有一行代码，可以省略大括号{}和return语句，编译器会自动推断返回值。
• 如果参数列表只有一个参数，可以省略括号()。

3. 函数式接口

Lambda表达式必须与函数式接口配合使用。函数式接口是指只包含一个抽象方法的接口。

Java 8提供了一些常用的函数式接口，例如：

• Runnable：无参数，无返回值。
• Callable：无参数，有返回值。
• Comparator：有参数，有返回值。
• Consumer：消费型接口，有参数，无返回值。
• Supplier：供给型接口，无参数，有返回值。
• Predicate：断言型接口，有参数，返回布尔值。

4. Lambda表达式的应用场景

4.1 运行线程

使用Lambda表达式简化线程的创建和启动：

// 传统方式
new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Thread is running.");
    }
}).start();

// 使用Lambda表达式
new Thread(() -> System.out.println("Thread is running.")).start();

4.2 集合排序

使用Lambda表达式对集合进行排序：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

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

        // 传统方式
        Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return s2.compareTo(s1);
            }
        });

        // 使用Lambda表达式
        Collections.sort(list, (s1, s2) -> s2.compareTo(s1));

        System.out.println(list); // [Python, Java, C++]
    }
}

4.3 集合遍历

使用Lambda表达式遍历集合：

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;

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

        // 使用Lambda表达式遍历集合
        list.forEach((s) -> System.out.println(s));
        // 或者省略参数类型
        list.forEach(s -> System.out.println(s));
    }
}

4.4 自定义函数式接口

定义一个函数式接口并使用Lambda表达式实现：

@FunctionalInterface
interface MyFunctionalInterface {
    void doSomething(String message);
}

public class Main {
    public static void main(String[] args) {
        // 使用Lambda表达式实现接口
        MyFunctionalInterface myInterface = (String message) -> System.out.println(message);
        // 调用方法
        myInterface.doSomething("Hello, Lambda!");
    }
}

5. Lambda表达式的优点

• 代码更简洁：减少了冗余代码，使代码更易读。
• 更灵活的编程：允许将行为作为参数传递。
• 函数式编程：支持函数式编程范式，提高代码复用性。

6. 总结

Lambda表达式是Java 8引入的一项重要特性，它简化了代码编写，提高了代码的可读性和可维护性。通过与函数式接口结合使用，Lambda表达式可以方便地实现各种功能，如线程创建、集合操作等。对于Java初学者来说，掌握Lambda表达式是迈向高级编程的重要一步。

Java Lambda表达式案例

以下是一些具体的Lambda表达式案例，帮助初学者理解其语法和使用场景。

案例1: 使用Lambda表达式实现Runnable接口

传统方式:

new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Thread is running.");
    }
}).start();

Lambda表达式方式:

new Thread(() -> System.out.println("Thread is running.")).start();

注释:

• 传统方式需要匿名内部类来实现Runnable接口。
• Lambda表达式简化了代码，省去了匿名内部类的繁琐。

案例2: 使用Lambda表达式进行集合排序

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

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

        // 使用Lambda表达式排序
        Collections.sort(list, (s1, s2) -> s2.compareTo(s1));

        System.out.println(list); // 输出: [Python, Java, C++]
    }
}

注释:

• 使用Lambda表达式作为Comparator，简化了排序逻辑。
• s2.compareTo(s1)实现降序排序。

案例3: 使用Lambda表达式遍历集合

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;

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

        // 使用Lambda表达式遍历集合
        list.forEach(s -> System.out.println(s));
    }
}

注释:

• forEach方法接受一个Consumer函数式接口。
• Lambda表达式s -> System.out.println(s)实现了消费逻辑。

案例4: 自定义函数式接口并使用Lambda表达式

@FunctionalInterface
interface MyFunctionalInterface {
    void doSomething(String message);
}

public class Main {
    public static void main(String[] args) {
        // 使用Lambda表达式实现接口
        MyFunctionalInterface myInterface = message -> System.out.println(message);
        // 调用方法
        myInterface.doSomething("Hello, Lambda!");
    }
}

注释:

• @FunctionalInterface注解表示这是一个函数式接口。
• Lambda表达式message -> System.out.println(message)实现了doSomething方法。

案例5: 使用不同类型的函数式接口

Predicate接口:

import java.util.function.Predicate;

public class Main {
    public static void main(String[] args) {
        Predicate<String> isEmpty = s -> s.isEmpty();
        System.out.println(isEmpty.test("")); // 输出: true
    }
}

Supplier接口:

import java.util.function.Supplier;

public class Main {
    public static void main(String[] args) {
        Supplier<String> greeting = () -> "Hello, World!";
        System.out.println(greeting.get()); // 输出: Hello, World!
    }
}

注释:

• Predicate用于判断条件，Supplier用于提供值。
• Lambda表达式简洁地实现了接口方法。

总结

通过这些案例，初学者可以更好地理解Lambda表达式的语法和应用场景。每个案例都配有详细的注释，帮助理解代码的每一部分。通过实践这些案例，初学者可以逐步掌握Lambda表达式的使用，提升代码编写效率。