Java 8 代码重构实战之一：用 Lambda、方法引用与 Stream API 打造现代代码

引言

Java 8 的发布带来了函数式编程的革新，显著提升了代码的简洁性和可维护性。本文将结合 匿名类重构、方法引用优化 和 Stream API 应用，展示如何将传统 Java 代码升级为现代化的高效实现。

---

1. 告别匿名类：拥抱 Lambda 表达式

传统匿名类 常用于实现单一方法的接口（如 Runnable, Comparator），但代码臃肿且不够直观。
Lambda 表达式 能简化这一过程，使代码更简洁。

示例 1：线程启动

// 旧代码：匿名类
new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Thread running");
    }
}).start();

// 重构后：Lambda 表达式
new Thread(() -> System.out.println("Thread running")).start();

示例 2：自定义排序

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

// 旧代码：匿名 Comparator
Collections.sort(names, new Comparator<String>() {
    @Override
    public int compare(String a, String b) {
        return a.length() - b.length();
    }
});

// 重构后：Lambda 表达式
Collections.sort(names, (a, b) -> a.length() - b.length());

// 更简洁的写法：Comparator.comparingInt
names.sort(Comparator.comparingInt(String::length));

重构优势：

• 代码行数减少 50% 以上。
• 逻辑清晰，直接表达“做什么”而非“如何做”。

---

2. 方法引用：让 Lambda 更优雅

当 Lambda 仅调用现有方法时，方法引用（Class::method）可以进一步简化代码，提升可读性。

方法引用类型

类型	示例	等效 Lambda
静态方法引用	Math::max	(a, b) -> Math.max(a, b)
实例方法引用	str::length	() -> str.length()
任意对象类型方法引用	String::toUpperCase	s -> s.toUpperCase()
构造方法引用	ArrayList::new	() -> new ArrayList<>()

示例 3：遍历列表

List<String> list = Arrays.asList("a", "b", "c");

// 旧代码：Lambda
list.forEach(s -> System.out.println(s));

// 重构后：方法引用
list.forEach(System.out::println);

示例 4：映射转换

List<String> words = Arrays.asList("hello", "world");

// 旧代码：Lambda 转换大写
List<String> upper = words.stream()
                          .map(s -> s.toUpperCase())
                          .collect(Collectors.toList());

// 重构后：方法引用
List<String> upper = words.stream()
                          .map(String::toUpperCase)
                          .collect(Collectors.toList());

重构优势：

• 代码更接近自然语言（如 String::toUpperCase）。
• 减少冗余参数，聚焦核心逻辑。

---

3. Stream API：声明式数据处理

Stream API 提供了一种声明式的数据操作方式，替代传统的循环和临时变量，支持链式调用和并行处理。

示例 5：过滤与收集

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

// 旧代码：循环过滤偶数
List<Integer> evenNumbers = new ArrayList<>();
for (Integer num : numbers) {
    if (num % 2 == 0) {
        evenNumbers.add(num);
    }
}

// 重构后：Stream API
List<Integer> evenNumbers = numbers.stream()
                                   .filter(n -> n % 2 == 0)
                                   .collect(Collectors.toList());

示例 6：复杂操作（映射+聚合）

// 旧代码：计算字符串总长度
int totalLength = 0;
for (String s : list) {
    totalLength += s.length();
}

// 重构后：Stream + mapToInt + sum
int totalLength = list.stream()
                     .mapToInt(String::length)
                     .sum();

示例 7：并行流加速处理

// 单线程流
long count = list.stream().filter(s -> s.startsWith("A")).count();

// 并行流（多核优化）
long count = list.parallelStream().filter(s -> s.startsWith("A")).count();

重构优势：

• 链式调用逻辑清晰，避免嵌套循环。
• 内置并行支持，轻松提升性能。
• 减少临时变量，降低副作用风险。

---

4. 综合实战：重构一段旧代码

原始代码：过滤并处理用户列表

List<User> users = getUserList();
List<String> names = new ArrayList<>();
for (User user : users) {
    if (user.getAge() > 18 && user.isActive()) {
        String name = user.getName().toUpperCase();
        names.add(name);
    }
}

重构后：

List<String> names = users.stream()
                          .filter(user -> user.getAge() > 18)
                          .filter(User::isActive) // 方法引用优化
                          .map(User::getName)
                          .map(String::toUpperCase)
                          .collect(Collectors.toList());

优化点：

1. 使用 filter 和 map 替代多层 if 嵌套。
2. 方法引用提升可读性。
3. 链式调用逻辑一目了然。

---

5. 注意事项

• 性能权衡：Stream API 在简单循环中可能略有性能损耗，但在复杂操作或并行场景下优势明显。
• 可读性优先：避免过度使用链式调用导致代码难以理解。
• Lambda 变量限制：Lambda 中只能引用 final 或等效 final 的局部变量。

---

结语

Java 8 的函数式特性彻底改变了代码的书写方式。通过 Lambda 表达式、方法引用 和 Stream API，开发者可以编写更简洁、高效且易于维护的代码。重构不是一蹴而就的，但逐步应用这些技巧，你的代码将焕然一新！