第1讲：为什么需要Java 8？—— 从行为参数化到Lambda

1. Java 8的革新背景与核心价值

Java 8的发布是Java语言发展史上的一个重要里程碑。在多核处理器和大数据处理成为主流的时代背景下，传统的面向对象编程模式在处理现代编程需求时显得力不从心。Java 8引入的函数式编程特性正是为了应对这些挑战，让开发者能够编写更简洁、可读性更强且易于并行化的代码。

核心革新体现在两个层面：行为参数化（将代码作为参数传递的能力）和 Lambda表达式（实现这一能力的简洁语法）。这些变化不仅减少了样板代码，更重要的是改变了我们思考编程问题的方式——从单纯的对象操作转向函数传递与组合。

2. 行为参数化模式详解

2.1 概念与原理

行为参数化是一种软件开发模式，它允许你定义一段代码块但不立即执行，而是将其作为参数传递给另一个方法，以便后续调用。这种模式的本质是 推迟执行——将可变的行为抽象出来，让方法的行为取决于传递进来的参数。

在Java 8之前，虽然可以通过接口和实现类实现类似功能，但代码十分冗长。行为参数化的核心价值在于它让代码能够更好地适应变化的需求，符合开闭原则（对扩展开放，对修改关闭）。

2.2 传统实现方式

让我们通过一个实际案例来理解行为参数化的演进过程。假设我们需要处理一个苹果库存，根据不同条件筛选苹果。

初始实现：重复代码的问题

// 筛选绿苹果
public static List<Apple> filterGreenApples(List<Apple> inventory) {
    List<Apple> result = new ArrayList<>();
    for(Apple apple: inventory) {
        if("green".equals(apple.getColor())) {
            result.add(apple);
        }
    }
    return result;
}

// 筛选重量超过150g的苹果
public static List<Apple> filterHeavyApples(List<Apple> inventory) {
    List<Apple> result = new ArrayList<>();
    for(Apple apple: inventory) {
        if(apple.getWeight() > 150) {
            result.add(apple);
        }
    }
    return result;
}

这种方法违反了DRY原则，当新增筛选条件时，需要编写几乎相同的方法，导致代码冗余。

3. 行为参数化的实战演进

3.1 定义策略接口

首先，我们将筛选标准抽象为一个接口：

public interface ApplePredicate {
    boolean test(Apple apple);
}

3.2 具体策略实现

针对不同筛选条件，实现具体的策略类：

// 筛选绿苹果的策略
public class AppleGreenColorPredicate implements ApplePredicate {
    @Override
    public boolean test(Apple apple) {
        return "green".equals(apple.getColor());
    }
}

// 筛选重量超过150g的策略
public class AppleHeavyWeightPredicate implements ApplePredicate {
    @Override
    public boolean test(Apple apple) {
        return apple.getWeight() > 150;
    }
}

// 组合条件：筛选红色且重量大的苹果
public class AppleRedAndHeavyPredicate implements ApplePredicate {
    @Override
    public boolean test(Apple apple) {
        return "red".equals(apple.getColor()) && apple.getWeight() > 150;
    }
}

3.3 统一的筛选方法

现在，我们可以编写一个通用的筛选方法：

public static List<Apple> filterApples(List<Apple> inventory, ApplePredicate predicate) {
    List<Apple> result = new ArrayList<>();
    for(Apple apple: inventory) {
        if(predicate.test(apple)) {
            result.add(apple);
        }
    }
    return result;
}

这种方法接收一个ApplePredicate对象作为参数，将筛选条件的具体实现委托给该对象。

4. 匿名类的弊端与局限性

4.1 匿名类的使用

虽然策略模式解决了代码重复的问题，但为每个筛选条件创建单独的类仍然很繁琐。匿名类提供了一种看似简洁的解决方案：

// 使用匿名类筛选绿苹果
List<Apple> greenApples = filterApples(inventory, new ApplePredicate() {
    @Override
    public boolean test(Apple apple) {
        return "green".equals(apple.getColor());
    }
});

// 使用匿名类筛选重量超过150g的苹果
List<Apple> heavyApples = filterApples(inventory, new ApplePredicate() {
    @Override
    public boolean test(Apple apple) {
        return apple.getWeight() > 150;
    }
});

4.2 匿名类的问题

尽管匿名类比创建独立类简洁，但仍存在以下问题：

1. 语法冗余：即使逻辑只有一行，也需要完整的类声明语法
2. 可读性差：样板代码掩盖了真正的业务逻辑
3. 性能问题：每个匿名类都会生成一个class文件，增加内存开销
4. 变量捕获限制：只能访问final或有效final的局部变量

这种笨拙的语法使得代码难以编写和维护，特别是当需要传递多个行为参数时。

5. Lambda表达式的简洁解决方案

5.1 Lambda表达式语法

Lambda表达式是匿名函数的简洁表示方式，由三部分组成：

• 参数列表：如 (Apple apple)
• 箭头符号：->
• 函数体：表达式或代码块

5.2 使用Lambda重写筛选逻辑

将匿名类替换为Lambda表达式：

// 筛选绿苹果
List<Apple> greenApples = filterApples(inventory, 
    apple -> "green".equals(apple.getColor()));

// 筛选重量超过150g的苹果
List<Apple> heavyApples = filterApples(inventory, 
    apple -> apple.getWeight() > 150);

// 组合条件：筛选红色且重量大的苹果
List<Apple> redAndHeavyApples = filterApples(inventory, 
    apple -> "red".equals(apple.getColor()) && apple.getWeight() > 150);

Lambda表达式去除了所有样板代码，只保留了最核心的逻辑，使代码变得极其简洁和清晰。

5.3 类型推断优化

Java编译器可以自动推断参数类型，使Lambda更加简洁：

// 可以省略Apple类型声明
List<Apple> greenApples = filterApples(inventory, 
    apple -> "green".equals(apple.getColor()));

// 多参数示例：比较苹果重量
inventory.sort((a1, a2) -> a1.getWeight().compareTo(a2.getWeight()));

6. 函数式接口与类型系统

6.1 函数式接口概念

Lambda表达式需要与函数式接口配合使用。函数式接口是只包含一个抽象方法的接口，如之前的ApplePredicate：

@FunctionalInterface
public interface ApplePredicate {
    boolean test(Apple apple);
}

@FunctionalInterface注解是可选的，但加上后编译器会检查接口是否符合函数式接口规则。

6.2 Java内置函数式接口

Java 8在java.util.function包中提供了常用的函数式接口，避免重复造轮子：

• Predicate：接收参数T，返回boolean（条件判断）
• Function<T,R>：接收参数T，返回结果R（类型转换）
• Consumer：接收参数T，无返回值（消费数据）
• Supplier：无参数，返回结果T（数据提供）

使用内置Predicate接口，我们可以泛化筛选方法：

public static <T> List<T> filter(List<T> list, Predicate<T> predicate) {
    List<T> result = new ArrayList<>();
    for(T item: list) {
        if(predicate.test(item)) {
            result.add(item);
        }
    }
    return result;
}

// 使用泛型方法筛选各种对象
List<Apple> redApples = filter(inventory, apple -> "red".equals(apple.getColor()));
List<Integer> evenNumbers = filter(numbers, n -> n % 2 == 0);

这样，同一个方法可以处理不同类型的集合，大大提高了代码复用性。

7. 实战案例：完整的苹果库存管理系统

7.1 多条件组合筛选

在实际开发中，我们经常需要动态组合多个条件：

// 组合多个Predicate
Predicate<Apple> redApple = apple -> "red".equals(apple.getColor());
Predicate<Apple> heavyApple = apple -> apple.getWeight() > 150;
Predicate<Apple> redAndHeavyApple = redApple.and(heavyApple);

List<Apple> result = filterApples(inventory, redAndHeavyApple);

7.2 行为参数化在排序中的应用

除了筛选，行为参数化也广泛应用于排序：

// 按重量排序
inventory.sort((a1, a2) -> a1.getWeight().compareTo(a2.getWeight()));

// 按颜色排序
inventory.sort((a1, a2) -> a1.getColor().compareTo(a2.getColor()));

// 多重排序：先按颜色，再按重量
inventory.sort((a1, a2) -> {
    int colorCompare = a1.getColor().compareTo(a2.getColor());
    return colorCompare != 0 ? colorCompare : a1.getWeight().compareTo(a2.getWeight());
});

8. 总结与最佳实践

8.1 Lambda表达式的优势

• 代码简洁性：大幅减少样板代码，突出核心逻辑
• 可读性提升：更接近自然语言的表达方式
• 灵活性增强：易于组合和重用行为逻辑
• 并行化支持：为后续Stream API和并行处理奠定基础

8.2 使用建议

1. 保持Lambda简短：复杂的逻辑应封装为方法，通过方法引用调用
2. 避免副作用：Lambda应尽可能纯净，不修改外部状态
3. 合理命名参数：帮助理解Lambda的意图
4. 适度使用：不是所有场景都适合Lambda，复杂业务逻辑仍需传统类

Java 8的行为参数化和Lambda表达式不仅仅是语法糖，它们代表了一种编程范式的转变，为函数式编程在Java中的应用打开了大门。掌握这些概念是学习后续Stream API、异步编程等高级特性的基础。

通过本章的学习，你应该已经理解了Lambda表达式解决的核心痛点，并能够在实际开发中运用行为参数化模式编写更简洁、灵活的代码。在接下来的章节中，我们将深入探讨Stream API，进一步发掘函数式编程的强大能力。

下期预告：第2讲：Lambda表达式精讲——语法、类型与使用场景

---

更多技术干货欢迎关注微信公众号“科威舟的AI笔记”~

【转载须知】：转载请注明原文出处及作者信息