【日积月累】Java Lambda 表达式

在这里插入图片描述

【日积月累】Java Lambda 表达式

1.前言
2.语法
3.应用场景
- 3.1简化匿名内部类的编写
- 3.1简化匿名内部类的编写
- 3.2简化集合类中的操作
- 3.3实现函数式接口
- 3.4简化多个方法的调用
- 3.5简化异步编程
4.总结
5.参考

文章所属专区日积月累

1.前言

Lambda表达式是一个匿名函数，也称闭包，允许把函数作为一个方法的参数，使用它设计的代码会更加简洁。当开发者在编写Lambda表达式时，也会随之被编译成一个函数式接口。

2.语法

Lambda表达式是用箭头（->）定义的，后面跟着一个或多个参数列表和方法体。

(parameters) -> expression

或

(parameters) ->{ statements; }

parameters是一个或多个参数列表，它们是用圆括号括起来的。参数列表是用逗号分隔的参数名称和类型的列表。方法体是在箭头后面的花括号内定义的代码块。
示例：

int x = 10;
int y = 20;
int sum = (a, b) -> a + b;
System.out.println(sum(x, y)); // 输出30

3.应用场景

3.1简化匿名内部类的编写

未使用前：

// 未使用Lambda表达式简化匿名内部类
public class MyClass {public static void main(String[] args) {new Thread() {@Overridepublic void run() {System.out.println("Hello, world!");}}.start();}
}

使用之后：

在这里插入代码片

3.1简化匿名内部类的编写

未使用前：

import java.util.ArrayList;
import java.util.List;public class AnonymousInnerClassExample {public static void main(String[] args) {List<Integer> list = new ArrayList<>();list.add(1);list.add(2);list.add(3);for (Integer i : list) {System.out.println(i);}}
}

使用之后：

import java.util.ArrayList;
import java.util.List;public class AnonymousInnerClassExample {public static void main(String[] args) {List<Integer> list = new ArrayList<>();list.add(1);list.add(2);list.add(3);list.forEach(System.out::println);}
}

Lambda表达式中的System.out::println是一个静态方法引用，它表示println()方法的调用。在Lambda表达式中，它被用于打印每个元素。

3.2简化集合类中的操作

public class AnonymousInnerClassExample {public static void main(String[] args) {List<Integer> list = new ArrayList<>();list.add(1);list.add(2);list.add(3);list.forEach(System.out::println);}
}

3.3实现函数式接口

只包含一个抽象方法的接口，就称为函数式接口。
我们可以在任意函数式接口上使用@FunctionalInterface注解，这样做可以用于检测它是否是一个函数式接口，同时javadoc也会包含一条声明，说明这个接口是一个函数式接口。
定义函数式接口：

@FunctionalInterface
public interface MyFuncInterf<T> {public T getValue(String origin);
}

使用函数式接口作为方法参数：

  public String toLowerString(MyFuncInterf<String> mf,String origin){return mf.getValue(origin);}

使用Lambda表达式实现的接口作为参数传递：

 public void test(){String result = toLowerString((str)->{return str.toLowerCase();},"ABC")；System.out.println(result);//结果abc}

3.4简化多个方法的调用

使用之后：

public static void main(String[] args) {String result = filter(list -> list.contains("apple"), "banana", "orange");System.out.println(result); // output: ["apple"]
}
public static <T> List<T> filter(Predicate<T> predicate, T... values) {return Arrays.stream(values).filter(predicate).collect(Collectors.toList());
}

3.5简化异步编程

使用之后：

// 使用Lambda表达式简化匿名内部类
public class MyClass {public static void main(String[] args) {Runnable runnable = new Runnable() {@Overridepublic void run() {System.out.println("Hello, world!");}};runnable.run();}
}// 使用Lambda表达式简化集合类中的操作
List<Integer> list = Arrays.asList(1, 2, 3);
list.forEach(i -> System.out.println(i * 2));// 使用Lambda表达式实现函数式接口
Supplier<String> greetingSupplier = () -> "Hello, ";
String greeting = greetingSupplier.get();// 使用Lambda表达式简化多个方法的调用
public void process(List<String> strings) {strings.forEach(string -> process(string));
}// 使用Lambda表达式简化异步编程
ExecutorService executorService = Executors.newFixedThreadPool(3);
Future<String> future1 = executorService.submit(() -> {try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}return "Task 1 completed";
});
Future<String> future2 = executorService.submit(() -> {try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}return "Task 2 completed";
});String result1 = future1.get();
String result2 = future2.get();
System.out.println(result1 + result2);