1 Lambda表达式
Lambda函数，也称为Lambda表达式，是Java 8版本新增的一项功能。它提供了一种简洁的方式来定义小型匿名函数，这些函数可以作为参数传递给其他方法或作为返回值使用。
语法:
Lambda表达式可以使用这个语法->来表示。
示例:
零参数：() -> expression
interface PrintInfo {
void print();
}
class TestLambda {
static void printJob(PrintInfo printInfo) {
printInfo.print();
}
public static void main(String[] args) {
printJob(() -> System.out.println("We're learning Java 8 fundamentals !"));
}
}Output: We’re learning Java 8 fundamentals !
一个参数：parameter -> expression
interface PrintInfo {
void print(String data);
}
class TestLambda {
static void printJob(PrintInfo printInfo, String data) {
printInfo.print(data);
}
public static void main(String[] args) {
printJob(statement -> System.out.println("We're learning " + statement), "Lambda");
}
}Output: We're learning Lambda
多个参数:(parameter1, parameter2) -> expression
interface PrintInfo {
void print(String data1, String data2);
}
class TestLambda {
static void printJob(PrintInfo printInfo, String data1, String data2) {
printInfo.print(data1, data2);
}
public static void main(String[] args) {
printJob((statement1, statement2) -> System.out.println("We're learning " + statement1 + " and "+ statement2), "Lambda", "it's uses");
}
}Output: We're learning Lambda and it's uses
复杂表达式：(parameter1, parameter2) -> { complex code block }
interface PrintInfo {
void print(String data1, String data2);
}
class TestLambda {
static void printJob(PrintInfo printInfo, String data1, String data2) {
printInfo.print(data1, data2);
}
public static void main(String[] args) {
printJob((statement1, statement2) -> {
System.out.println("We're learning " + statement1 + " and "+ statement2);
System.out.println("This is a multi line lambda");
System.out.println("This is a complex lambda implementation");
},
"Lambda",
"it's uses"
);
}
}Output: We’re learning Lambda and it’s uses
This is a multi line lambda
This is a complex lambda implementation
2 方法引用
方法引用是一种紧凑、易读的Lambda表达式，用于已经具有名称的方法。简单地说，我们可以使用方法引用从Lambda函数中调用方法。
语法:
Object::method
让我们来看看如何使用Lambda打印列表中的元素:
public void print(List<String> list) {
list.forEach(l -> System.out.println(l));
}可以使用方法引用，如下所示:
public void print(List<String> list) {
list.forEach(System.out::println);
}如您所见，这使代码更加清晰、精确和易于阅读。
同样地，我们可以使用Classname::methodName来表示对静态方法的调用。
public static void main(String[]args){
List<String> fruits = new ArrayList<>();
fruits.add("mango");
fruits.add("banana");
fruits.add("kiwi");
fruits.add("orange");
fruits.forEach(Test::process);
}
private static void process(String value) {
System.out.println("processed fruit: " + value);
}同时，我们可以使用Object to be instantiated::new来使用方法引用引用构造函数。
public static void main(String[]args){
List<String> fruits = new ArrayList<>();
fruits.add("mango");
fruits.add("banana");
fruits.add("kiwi");
fruits.add("orange");
fruits.stream()
.map(Fruit::new)
.toArray(Fruit[]::new);
}
class Fruit {
public Fruit(String name) {
this.name = name;
}
}方法引用也可以用于Comparator。
按名称对水果列表排序:
public static void process(List<Fruit> fruits) {
fruits.stream()
.sorted(Comparator.comparing(Fruit::getName))
.forEach(System.out::println);
}3 Lambda的不同用途
遍历列表
public static void main(String[] args) {
List<String> fruits = List.of("mango", "oranges", "banana", "kiwi", "apple");
fruits.forEach(fruit -> System.out.println(fruit));
}遍历Map
public static void main(String[] args) {
Map<String, Integer> map = new HashMap<>();
map.put("value1", 10);
map.put("value2", 20);
map.put("value3", 30);
map.put("value4", 40);
map.forEach((key, value) -> System.out.println("key: " + key + ", value: " + value));
}创建Runnable和Callable
Runnable是一个函数式接口，因此我们可以使用Lambda表达式来表示它。
使用匿名类创建Runnable的典型方式
public static void main(String[] args) {
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println("Hello World !");
}
};
}同样的Lambda表达式实现如下：
public static void main(String[] args) {
Runnable runnable = () -> System.out.println("Hello World !");
}同样地，Callable也可以实现：
public static void main(String args[]) throws InterruptedException {
Callable<Integer> callable = () -> {
int sum = 0;
for (int i = 0; i < 5; i++) {
sum += i;
}
return sum;
};
}Predicate
使用Lambda函数表示Predicate：
public class HelloWorld{
public static void main(String []args){
Predicate<Integer> predicate = (i) -> i > 10;
System.out.println(predicate.test(15));
}
}Output: True
Consumer
使用Lambda函数表示Consumer:
public class HelloWorld{
public static void main(String []args){
//例1
Consumer<Integer> consumer = System.out::println;
consumer.accept(10);
//例2
List<String> inputs = new ArrayList<>();
Consumer<String> consumer = str -> inputs.add(str);
consumer.accept("first");
consumer.accept("second");
inputs.forEach(e -> System.out.println(e));
}
}Example 1 output: 10,Example 2 output: first \n second
Comparator
Comparator是Java中的一个函数式接口，因此我们可以使用Lambda函数来表示它。
下面我们使用Lambda创建一个Comparator：
public static void process(List<Movie> movies) {
Comparator<Movie> movieComparator = (m1, m2) -> m1.getRating() - m2.getRating();
movies.sort(movieComparator);
}让我们看看更多的例子：
按自然顺序排序数字列表：
private static void process(List<Integer> numbers) {
numbers.stream()
.sorted(Comparator.naturalOrder())
.forEach(System.out::println);
}如果我们要根据多个参数对列表进行排序，则可以使用Comparator的thenComparing方法，如下所示：
private static void process(List<Movie> movies) {
movies.stream()
.sorted(Comparator.comparing(Movie::getName)
.thenComparing(Movie::getRating)
)
.forEach(System.out::println);
}将排序后的列表反转:
private static void process(List<Movie> movies) {
movies.stream()
.sorted(Comparator.comparing(Movie::getName)
.thenComparing(Movie::getRating)
.reversed())
.forEach(System.out::println);
}4 总结
本文中，我们探讨了Lambda函数，看了很多不同的Lambda函数的例子，我们还了解了如何使用方法引用和Comparator。
