详情页

2025-06-30

14

原创

1、使用 Lambda 创建 Runnable 实例

Runnable r = () -> System.out.println("你好, Lambda!");
new Thread(r).start();

2、使用 Lambda 遍历列表 (forEach)

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

List<String> list = Arrays.asList("Java", "Spring", "Lambda");
list.forEach(item -> System.out.println(item));

3、使用 Lambda 和 Stream 过滤列表 (filter)

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

List<String> list = Arrays.asList("Java", "JavaScript", "Python");
List<String> filteredList = list.stream()
    .filter(s -> s.startsWith("J")) // 过滤出以 "J" 开头的字符串
    .collect(Collectors.toList());
filteredList.forEach(System.out::println);

4、使用 Lambda 排序列表 (list.sort)

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

List<String> list = Arrays.asList("Java", "Lambda", "Kafka");
list.sort((s1, s2) -> s1.compareTo(s2)); // 按字母顺序排序
list.forEach(System.out::println);

5、使用自定义函数式接口

@FunctionalInterface // 标记为函数式接口
interface Calculator {
    int calculate(int a, int b);
}

public static void main(String[] args) {
    Calculator add = (a, b) -> a + b;
    Calculator multiply = (a, b) -> a * b;
    System.out.println("加法: " + add.calculate(5, 3));
    System.out.println("乘法: " + multiply.calculate(5, 3));
}

6、使用 Lambda 遍历 Map (forEach)

import java.util.HashMap;
import java.util.Map;

Map<String, Integer> map = new HashMap<>();
map.put("Java", 8);
map.put("Spring", 5);
map.put("Lambda", 1);
map.forEach((key, value) -> System.out.println(key + ": " + value));

7、使用 Lambda 创建并启动线程

new Thread(() -> System.out.println("使用 Lambda 创建的线程!")).start();

8、在比较器 (Comparator) 中使用 Lambda

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

List<String> list = Arrays.asList("Java", "Lambda", "Kafka");
list.sort(Comparator.comparingInt(String::length)); // 按字符串长度排序
list.forEach(System.out::println);

9、结合 Lambda 使用方法引用 (::)

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

List<String> list = Arrays.asList("Java", "Lambda", "Kafka");
list.forEach(System.out::println); // 使用方法引用代替 s -> System.out.println(s)

10、结合 Lambda 使用 Optional

import java.util.Optional;

Optional<String> optional = Optional.of("Java");
optional.ifPresent(s -> System.out.println("值存在: " + s));

11、使用 Predicate 函数式接口

import java.util.function.Predicate;

Predicate<String> isEmpty = s -> s.isEmpty();
System.out.println("测试空字符串: " + isEmpty.test("")); // true
System.out.println("测试'Java': " + isEmpty.test("Java")); // false

12、使用 BiFunction 函数式接口

import java.util.function.BiFunction;

BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;
System.out.println("2 + 3 = " + add.apply(2, 3)); // 5

13、使用 Consumer 函数式接口

import java.util.function.Consumer;

Consumer<String> print = s -> System.out.println(s);
print.accept("你好, 世界!"); // 你好, 世界!

14、使用 Supplier 函数式接口

import java.util.function.Supplier;

Supplier<String> supplier = () -> "Java";
System.out.println("提供的值: " + supplier.get()); // Java

15、使用 Stream 的 sorted() 方法进行自然排序

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

List<String> list = Arrays.asList("Banana", "Pear", "Grapes", "Apple");
list.stream()
    .sorted() // 按自然顺序排序
    .forEach(System.out::println);

16、使用 Stream 的 count() 方法统计元素数量

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

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
long count = numbers.stream().count();
System.out.println("数量: " + count); // 数量: 5

17、使用 Stream 的 anyMatch() 方法检查是否存在匹配项

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

List<String> list = Arrays.asList("Java", "Spring", "Lambda");
boolean containsJava = list.stream()
    .anyMatch(s -> s.equals("Java"));
System.out.println("是否包含 'Java': " + containsJava); // true

18、使用 Stream 的 allMatch() 方法检查是否所有项都匹配

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

List<Integer> numbers = Arrays.asList(2, 4, 6, 8, 10);
boolean allEven = numbers.stream()
    .allMatch(n -> n % 2 == 0);
System.out.println("是否所有都是偶数: " + allEven); // true

19、使用 Stream 的 noneMatch() 方法检查是否所有项都不匹配

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

List<String> list = Arrays.asList("Java", "Spring", "Lambda");
boolean nonePython = list.stream()
    .noneMatch(s -> s.equals("Python"));
System.out.println("是否不包含 'Python': " + nonePython); // true

20、使用 Stream 的 findFirst() 方法查找第一个元素

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

List<String> list = Arrays.asList("Java", "Spring", "Lambda");
Optional<String> first = list.stream().findFirst();
first.ifPresent(System.out::println); // Java

使用 Stream 的 findAny() 方法查找任意一个元素

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

List<String> list = Arrays.asList("Java", "Spring", "Lambda");
Optional<String> any = list.stream().findAny();
any.ifPresent(System.out::println); // 在非并行流中通常是第一个元素 "Java"

使用 Lambda 和 Stream 对整数求和 (sum)

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

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream()
    .mapToInt(Integer::intValue) // 转换为 IntStream
    .sum();
System.out.println("总和: " + sum); // 总和: 15

23、使用 Lambda 和 Stream 查找最大整数 (max)

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

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int max = numbers.stream()
    .mapToInt(Integer::intValue)
    .max()
    .orElse(Integer.MIN_VALUE); // 如果流为空，则返回默认值
System.out.println("最大值: " + max); // 最大值: 5

24、使用 Lambda 和 Stream 查找最小整数 (min)

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

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int min = numbers.stream()
    .mapToInt(Integer::intValue)
    .min()
    .orElse(Integer.MAX_VALUE); // 如果流为空，则返回默认值
System.out.println("最小值: " + min); // 最小值: 1

25、使用 Lambda 和 Stream 连接字符串 (Collectors.joining)

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

List<String> list = Arrays.asList("Java", "Spring", "Lambda");
String joined = list.stream()
    .collect(Collectors.joining(", ")); // 使用 ", " 作为分隔符
System.out.println(joined); // Java, Spring, Lambda

26、使用 Stream 的 mapToInt() 方法

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

List<String> list = Arrays.asList("Java", "Spring", "Lambda");
list.stream()
    .mapToInt(String::length) // 将字符串映射为其长度 (int)
    .forEach(System.out::println); // 4, 6, 6

27、使用 Stream 将结果收集到 Set 中 (toSet)

import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

List<String> list = Arrays.asList("Java", "Spring", "Lambda", "Spring"); // 包含重复元素
Set<String> set = list.stream()
    .collect(Collectors.toSet()); // 收集到 Set 中，自动去重
set.forEach(System.out::println); // Java, Spring, Lambda (顺序不保证)

28、使用 Stream 的 groupingBy() 进行分组计数

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

List<String> list = Arrays.asList("Java", "Spring", "Lambda", "Java");
Map<String, Long> frequency = list.stream()
    .collect(Collectors.groupingBy(s -> s, Collectors.counting())); // 按字符串本身分组，并统计数量
frequency.forEach((k, v) -> System.out.println(k + ": " + v));
// 输出 (顺序不保证):
// Java: 2
// Lambda: 1
// Spring: 1

29、使用 Stream 的 partitioningBy() 进行分区

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
// 根据条件 (是否为偶数) 将数字分为两组
Map<Boolean, List<Integer>> partitioned = numbers.stream()
    .collect(Collectors.partitioningBy(n -> n % 2 == 0));
partitioned.forEach((k, v) -> System.out.println(k + ": " + v));
// 输出:
// false: [1, 3, 5, 7, 9]
// true: [2, 4, 6, 8, 10]

30、使用 Collectors.counting() 进行计数

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

List<String> list = Arrays.asList("Java", "Spring", "Lambda");
long count = list.stream()
    .collect(Collectors.counting()); // 功能等同于 .count()
System.out.println("数量: " + count); // 数量: 3

使用 Collectors.summarizingInt() 获取统计信息

import java.util.Arrays;
import java.util.IntSummaryStatistics;
import java.util.List;
import java.util.stream.Collectors;

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
IntSummaryStatistics stats = numbers.stream()
    .collect(Collectors.summarizingInt(Integer::intValue));
System.out.println("总和: " + stats.getSum());
System.out.println("平均值: " + stats.getAverage());
System.out.println("最大值: " + stats.getMax());
System.out.println("最小值: " + stats.getMin());

使用 Stream 的 groupingBy() 进行分组映射

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

List<String> list = Arrays.asList("Java", "Spring", "Lambda");
// 按字符串长度进行分组
Map<Integer, List<String>> map = list.stream()
    .collect(Collectors.groupingBy(String::length));
map.forEach((k, v) -> System.out.println(k + ": " + v));
// 输出 (顺序不保证):
// 4: [Java]
// 6: [Spring, Lambda]

33、使用 Stream 的 joining() 无分隔符连接

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

List<String> list = Arrays.asList("Java", "Spring", "Lambda");
String joined = list.stream()
    .collect(Collectors.joining()); // 不提供分隔符
System.out.println(joined); // JavaSpringLambda

34、使用 Stream 的 toMap() 收集为 Map

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

List<String> list = Arrays.asList("Java", "Spring", "Lambda");
// key 是字符串本身，value 是其长度
Map<String, Integer> map = list.stream()
    .collect(Collectors.toMap(s -> s, String::length));
map.forEach((k, v) -> System.out.println(k + ": " + v));
// 输出 (顺序不保证):
// Java: 4
// Lambda: 6
// Spring: 6

35、使用 Stream.of() 创建流

import java.util.stream.Stream;

Stream<String> stream = Stream.of("Java", "Spring", "Lambda");
stream.forEach(System.out::println);

36、使用 Stream 的 limit() 方法截取流

import java.util.stream.Stream;

Stream<String> stream = Stream.of("Java", "Spring", "Lambda", "Kafka");
stream.limit(2) // 只取前 2 个元素
    .forEach(System.out::println); // Java, Spring

37、使用 Stream 的 skip() 方法跳过元素

import java.util.stream.Stream;

Stream.of("A", "B", "C", "D", "E")
    .skip(2) // 跳过流中的前 2 个元素
    .forEach(System.out::println); // 输出 C, D, E

38、使用 Stream 的 peek() 方法进行调试/观察

import java.util.stream.Collectors;
import java.util.stream.Stream;

Stream<String> stream = Stream.of("Java", "Spring", "Lambda", "Kafka");
// peek() 用于在流的每个元素被消费时执行一个操作，常用于调试
stream.peek(s -> System.out.println("正在处理: " + s))
    .collect(Collectors.toList()); // 需要一个终端操作来触发 peek

39、结合 Lambda 使用 Optional 的 ifPresent

import java.util.Optional;

Optional<String> optional = Optional.of("Java");
optional.ifPresent(System.out::println); // Java

40、使用 Stream 的 distinct() 方法去重

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

List<String> list = Arrays.asList("Java", "Spring", "Java", "Lambda");
list.stream()
    .distinct() // 去除重复的 "Java"
    .forEach(System.out::println); // Java, Spring, Lambda

使用 Stream 的 flatMap() 方法进行扁平化映射

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

List<List<String>> listOfLists = Arrays.asList(
    Arrays.asList("Java", "Spring"),
    Arrays.asList("Lambda", "Kafka")
);
// 将 Stream<List<String>> 扁平化为 Stream<String>
listOfLists.stream()
    .flatMap(List::stream)
    .forEach(System.out::println); // Java, Spring, Lambda, Kafka

使用 Stream 的 reduce() 方法进行归约操作

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

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
// 0 是初始值，(a, b) -> a + b 是累加器
int sum = numbers.stream()
    .reduce(0, (a, b) -> a + b);
System.out.println("总和: " + sum); // 总和: 15

43、使用 Stream 的 map() 方法进行转换

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

List<String> list = Arrays.asList("Java", "Spring", "Lambda");
list.stream()
    .map(String::toUpperCase) // 将每个字符串转换为大写
    .forEach(System.out::println); // JAVA, SPRING, LAMBDA

44、结合使用 Stream 的 filter() 和 map()

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

List<String> list = Arrays.asList("Java", "Spring", "Lambda");
list.stream()
    .filter(s -> s.startsWith("J")) // 先过滤
    .map(String::toUpperCase)       // 再转换
    .forEach(System.out::println); // JAVA

45、使用 Stream 的 sorted() 和自定义比较器排序

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

List<String> list = Arrays.asList("Java", "Spring", "Lambda");
list.stream()
    .sorted((s1, s2) -> s2.compareTo(s1)) // 按字母倒序排序
    .forEach(System.out::println); // Spring, Lambda, Java

46、使用 Stream.iterate() 创建无限流

import java.util.stream.Stream;

// 从 0 开始，每次加 2，生成一个无限的偶数序列
Stream.iterate(0, n -> n + 2)
    .limit(5) // 必须使用 limit() 截断，否则会无限执行
    .forEach(System.out::println); // 0, 2, 4, 6, 8

47、使用 Stream.generate() 创建无限流

import java.util.stream.Stream;

// 生成一个包含重复 "Java" 字符串的无限流
Stream.generate(() -> "Java")
    .limit(3) // 同样需要 limit() 截断
    .forEach(System.out::println); // Java, Java, Java

48、使用 IntStream 创建原始类型流

import java.util.stream.IntStream;

// 创建一个从 1 到 3 (不包括 4) 的整数流
IntStream.range(1, 4)
    .forEach(System.out::println); // 1, 2, 3

49、使用 Stream 的 toArray() 方法转换为数组

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

List<String> list = Arrays.asList("Java", "Spring", "Lambda");
String[] array = list.stream()
    .toArray(String[]::new); // 提供一个数组构造器引用
System.out.println(Arrays.toString(array)); // [Java, Spring, Lambda]

50、使用 collect(Collectors.toList()) 收集为列表

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

Stream<String> stream = Stream.of("Java", "Spring", "Lambda");
List<String> collectedList = stream
    .collect(Collectors.toList());
System.out.println(collectedList); // [Java, Spring, Lambda]

Java

作者：一介闲人(联系作者)

发表时间： 2025-06-30 18:01

公众号转载：请在文末添加本文链接

Lambda小技巧

评论

Lambda小技巧

评论

不让你联系，略略略~

(请点击任意空白位置关闭)