文章目录
- 1. **实现Runnable接口**：
- 2. **事件监听器**（如Swing中的ActionListener）：
- 3. **集合遍历**（使用`forEach`方法）：
- 4. **过滤集合**（使用Stream API）：
- 5. **映射集合元素**：
- 6. **排序集合**：
- 7. **函数引用作为lambda**：
- 8. **使用Consumer接口**：
- 9. **Predicate接口的应用**：
- 10. **使用Supplier接口**：
- 11. **使用Function接口**：
- 12. **并行流处理**：
- 13. **Optional类的map和filter方法**：
- 14. **比较器构造**（Comparator.comparing()）：
- 15. **方法引用作为lambda的返回值**：
当然，以下是Java Lambda表达式的10个典型使用案例：
1. 实现Runnable接口：
// 在Java 8之前，我们这样写：
new Thread(new Runnable() {@Overridepublic void run() {System.out.println("Hello from a thread");}
}).start();// 使用lambda简化后：
new Thread(() -> System.out.println("Hello from a thread")).start();
2. 事件监听器（如Swing中的ActionListener）：
// 传统匿名类方式：
button.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {System.out.println("Button clicked");}
});// 使用lambda表达式：
button.addActionListener(e -> System.out.println("Button clicked"));
3. 集合遍历（使用forEach方法）：
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");// 非lambda方式：
for (String name : names) {System.out.println(name);
}// 使用lambda表达式：
names.forEach(name -> System.out.println(name));
4. 过滤集合（使用Stream API）：
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);List<Integer> evenNumbers = numbers.stream().filter(n -> n % 2 == 0).collect(Collectors.toList());
5. 映射集合元素：
List<String> words = Arrays.asList("apple", "banana", "cherry");List<Integer> wordLengths = words.stream().map(String::length).collect(Collectors.toList());
6. 排序集合：
List<Person> people = ...; // 假设Person有getName()方法Collections.sort(people, (p1, p2) -> p1.getName().compareTo(p2.getName()));// 或者使用Stream API
List<Person> sortedPeople = people.stream().sorted(Comparator.comparing(Person::getName)).collect(Collectors.toList());
7. 函数引用作为lambda：
List<String> list = Arrays.asList("a", "aa", "aaa");
list.sort((s1, s2) -> s1.length() - s2.length()); // 使用lambda进行长度比较排序
list.sort(Comparator.comparing(String::length)); // 使用函数引用简化
8. 使用Consumer接口：
BiConsumer<String, String> printer = (x, y) -> System.out.println(x + ", " + y);
printer.accept("Hello", "World");
9. Predicate接口的应用：
Predicate<String> isLongEnough = s -> s.length() > 5;
boolean result = isLongEnough.test("longEnoughString");
10. 使用Supplier接口：
```java
Supplier<String> randomNameGenerator = () -> "Random Name " + Math.random();
String newName = randomNameGenerator.get();
```
11. 使用Function接口：
```java
Function<String, Integer> stringLength = s -> s.length();
int length = stringLength.apply("Hello World");
```
12. 并行流处理：
```java
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.parallelStream().mapToInt(i -> i * i).sum();
```
13. Optional类的map和filter方法：
```java
Optional<String> optional = Optional.of("Hello");
String upperCased = optional.map(s -> s.toUpperCase()).orElse("default");
```
14. 比较器构造（Comparator.comparing()）：
```java
List<Student> students = ...; // 假设Student有getScore()方法
Collections.sort(students, Comparator.comparing(Student::getScore).reversed());
```
15. 方法引用作为lambda的返回值：
```java
BiFunction<String, String, String> concat = String::concat;
String result = concat.apply("Hello", "World"); // 输出: HelloWorld
```
以上示例进一步展示了Java Lambda在函数式编程、集合操作以及处理Optional对象等场景中的应用。
python学习汇总连接：
50个开发必备的Python经典脚本(1-10)
50个开发必备的Python经典脚本(11-20)
50个开发必备的Python经典脚本(21-30)
50个开发必备的Python经典脚本(31-40)
50个开发必备的Python经典脚本(41-50)
————————————————
最后我们放松一下眼睛
)
