地基JDK8新特性之Lambda 表达式和Stream 流操作

一、Lambda 表达式基础

1. 替代匿名内部类

// 传统写法
Runnable r1 = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello World");
    }
};

// Lambda 写法
Runnable r2 = () ->  {
            System.out.println("hello");
        };

2. 函数式接口排序

List<String> list = Arrays.asList("apple", "banana", "orange");

// 传统 Comparator
list.sort(new Comparator<String>() {
    @Override
    public int compare(String s1, String s2) {
        return s1.length() - s2.length();
    }
});

// Lambda 写法
list.sort((s1, s2) -> s1.length() - s2.length());

二、Stream 流操作

1. 过滤（Filter）

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);

// 获取所有偶数
List<Integer> evenNumbers = numbers.stream()
    .filter(n -> n % 2 == 0)
    .collect(Collectors.toList()); // [2, 4, 6]

2. 映射（Map）

List<String> words = Arrays.asList("java", "python", "c++");

// 转为大写
List<String> upperCaseWords = words.stream()
    .map(String::toUpperCase)
    .collect(Collectors.toList()); // [JAVA, PYTHON, C++]

3. 排序（Sorted）

List<String> names = Arrays.asList("Tom", "Jerry", "Alice");

// 按长度排序
List<String> sortedNames = names.stream()
    .sorted((s1, s2) -> s1.length() - s2.length())
    .collect(Collectors.toList()); // [Tom, Alice, Jerry]

4. 收集（Collect）转set、map

// 转为 Set
Set<Integer> numberSet = numbers.stream()
    .collect(Collectors.toSet());

// 转为 Map
Map<String, Integer> wordLengthMap = words.stream()
    .collect(Collectors.toMap(
        word -> word, 
        word -> word.length()
    ));

5. 去重（Distinct）

List<Integer> nums = Arrays.asList(1, 2, 2, 3, 3, 3);
List<Integer> distinctNums = nums.stream()
    .distinct()
    .collect(Collectors.toList()); // [1, 2, 3]

6. 限制和跳过（Limit & Skip）

// 分页操作：跳过前2个，取3个
List<Integer> page = numbers.stream()
    .skip(2)
    .limit(3)
    .collect(Collectors.toList()); // [3, 4, 5]

7. 匹配（Match）

boolean hasEven = numbers.stream()
    .anyMatch(n -> n % 2 == 0); // true

boolean allEven = numbers.stream()
    .allMatch(n -> n % 2 == 0); // false

8. 统计（Count/Sum/Average）

long count = numbers.stream().count(); // 6

int sum = numbers.stream()
    .mapToInt(Integer::intValue)
    .sum(); // 21

OptionalDouble avg = numbers.stream()
    .mapToInt(Integer::intValue)
    .average(); // 3.5

9. 分组（GroupingBy）

List<String> languages = Arrays.asList("Java", "Python", "C++", "JavaScript");

// 按字符串长度分组
Map<Integer, List<String>> groupByLength = languages.stream()
    .collect(Collectors.groupingBy(String::length));
// 输出：{2=[C++], 4=[Java], 6=[Python], 10=[JavaScript]}

10. 连接字符串（Joining）

String joined = languages.stream()
    .collect(Collectors.joining(", "));
// 输出：Java, Python, C++, JavaScript

三、并行流（Parallel Stream）

// 使用并行流提升处理速度
long count = numbers.parallelStream()
    .filter(n -> n % 2 == 0)
    .count();

总结特性：

1. Lambda 表达式：简化匿名内部类，使代码更简洁

2. Stream API：

   • 链式调用：支持多个操作串联

   • 延迟执行：只有遇到终止操作时才会执行

   • 并行处理：通过 parallelStream() 实现并行化

3. 常用操作分类：

   • 中间操作：filter, map, sorted, distinct 等

   • 终止操作：collect, forEach, count, reduce 等

通过组合这些操作，可以高效处理集合数据，且代码可读性大幅提升。

（望各位潘安、各位子健/各位彦祖、于晏不吝赐教！多多指正！🙏）