Java中 Lambda表达式如何实现匿名函数

Java中 Lambda表达式如何实现匿名函数

在Java中，Lambda表达式被用来实现匿名函数，即没有名称的函数。它们主要用于需要一个函数式接口实例的地方，例如作为参数传递给另一个方法，或者用于定义简短的函数逻辑。

Lambda表达式的基本语法如下：

(parameter-list) -> { function-body }
1

其中，parameter-list是输入参数，->是Lambda操作符，function-body是Lambda函数体，包含了需要执行的代码。

以下是一个Lambda表达式的例子，它实现了Runnable接口的run方法：

Runnable runnable = () -> {
    System.out.println("Hello, Lambda!");
};

runnable.run(); // 输出 "Hello, Lambda!"
1
2
3
4
5

在这个例子中，Lambda表达式() -> { System.out.println("Hello, Lambda!"); }实现了Runnable接口的run方法。我们没有明确地为这个函数命名，因此它是一个匿名函数。

Lambda表达式也可以用于实现Java 8中引入的函数式接口，如Function、Predicate、Consumer等。例如，以下是一个使用Lambda表达式实现Predicate接口的例子：

List<String> names = Arrays.asList("Peter", "Anna", "Mike", "Xenia");

// 使用Lambda表达式筛选所有长度大于4的名字
Collection<String> result = names.stream()
    .filter(name -> name.length() > 4)
    .collect(Collectors.toList());

result.forEach(System.out::println); // 输出长度大于4的名字
1
2
3
4
5
6
7
8

在这个例子中，name -> name.length() > 4是一个Lambda表达式，它实现了Predicate接口的test方法，用于判断一个字符串的长度是否大于4。

Lambda表达式的优势在于它们提供了更加简洁和灵活的方式来表达函数式逻辑，而不需要显式地定义类和方法。这使得代码更加易读、易写，并且减少了样板代码的数量。

lambda表达式来定义一个排序函数？

在Java中，你可以使用Lambda表达式来定义一个排序函数，并将其传递给Collections.sort()方法或者List.sort()方法，或者直接作为参数传递给那些需要Comparator接口的方法，比如Stream.sorted()。以下是一个例子，展示如何使用Lambda表达式来定义一个排序函数，用于对一个List中的字符串按照长度进行排序：

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

public class LambdaSortExample {
    public static void main(String[] args) {
        // 创建一个字符串列表
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Eve");

        // 使用Lambda表达式定义排序函数，按照字符串长度排序
        // (String a, String b) -> a.length() - b.length() 是一个Comparator
        names.sort((String a, String b) -> a.length() - b.length());

        // 打印排序后的列表
        names.forEach(System.out::println);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

在这个例子中，Lambda表达式(String a, String b) -> a.length() - b.length()定义了一个比较器（Comparator），它接收两个字符串参数a和b，并返回它们的长度差。这个比较器被传递给List.sort()方法，该方法使用它来排序列表中的元素。

你也可以使用更简洁的方法引用语法，如果排序逻辑很简单，例如按自然顺序排序，你可以这样做：

import java.util.Arrays;
import java.util.List;

public class LambdaSortExample {
    public static void main(String[] args) {
        // 创建一个字符串列表
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Eve");

        // 使用自然顺序排序
        names.sort(null); // 默认使用自然顺序排序

        // 或者使用Comparator.naturalOrder()
        // names.sort(Comparator.naturalOrder());

        // 打印排序后的列表
        names.forEach(System.out::println);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

在这个例子中，我们没有显式地定义Lambda表达式，而是直接调用了List.sort()方法，没有传递任何参数。这会导致列表按照元素的自然顺序进行排序。

对于自定义对象的排序，你也可以使用Lambda表达式来定义比较器：

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

class Person {
    String name;
    int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // getters and setters

    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
                new Person("Alice", 28),
                new Person("Bob", 24),
                new Person("Charlie", 30)
        );

        // 使用Lambda表达式按照年龄排序
        people.sort(Comparator.comparingInt(Person::getAge));

        // 打印排序后的列表
        people.forEach(person -> System.out.println(person.getName() + ": " + person.getAge()));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

在这个例子中，我们定义了一个Person类，并使用Lambda表达式和Comparator.comparingInt()方法来按照Person对象的年龄进行排序。