Java 8 Lambda表达式：函数式编程的优雅之门

Java 8 最引人注目的特性非 Lambda 表达式莫属。它不仅仅是语法糖，更是 Java 向函数式编程范式转型的重要里程碑。通过
Lambda，我们能用更少的代码表达复杂的行为，让代码更加简洁、灵活。

Lambda 表达式：匿名函数的简洁表示
Lambda 表达式本质上是一个匿名函数——没有名称，但有参数列表、函数体和可能的返回类型。它让我们能够将函数作为方法参数传递，或者将代码作为数据处理。

java
// 传统匿名内部类
Runnable oldWay = new Runnable() {
@Override
public void run() {
System.out.println(“Hello World”);
}
};

// Lambda 表达式
Runnable newWay = () -> System.out.println(“Hello World”);

// 调用方式相同
oldWay.run();
newWay.run();
Lambda 语法：从简单到复杂
Lambda 表达式的基本语法是：(parameters) -> expression 或 (parameters) -> { statements; }

基本形式
java
// 1.1 无参数
() -> System.out.println(“无参数Lambda”);

// 1.2 单个参数（可省略括号）
str -> str.toUpperCase();

// 1.3 多个参数
(x, y) -> x + y;

// 1.4 指定参数类型
(String s, int i) -> s.length() > i;

函数体形式
java
// 2.1 表达式体（单行，自动返回结果）
(int x, int y) -> x * y;

// 2.2 语句体（多行，需显式返回）
(int x, int y) -> {
int result = x * y;
System.out.println(“计算结果: “ + result);
return result;
};

方法引用：更简洁的Lambda
java
// Lambda表达式
list.forEach(item -> System.out.println(item));

// 方法引用（更简洁）
list.forEach(System.out::println);
Lambda 的核心用途

替代匿名内部类
java
public class LambdaDemo {
public static void main(String[] args) {
// 线程创建对比
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println(“传统方式”);
}
});

 Thread thread2 = new Thread(() -> System.out.println("Lambda方式"));
 
 // 事件监听器对比
 JButton button = new JButton("Click");
 
 // 传统方式
 button.addActionListener(new ActionListener() {
     @Override
     public void actionPerformed(ActionEvent e) {
         System.out.println("按钮被点击");
     }
 });
 
 // Lambda方式
 button.addActionListener(e -> System.out.println("按钮被点击"));
 
 // 排序对比
 List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
 
 // 传统方式
 Collections.sort(names, new Comparator<String>() {
     @Override
     public int compare(String s1, String s2) {
         return s1.compareTo(s2);
     }
 });
 
 // Lambda方式
 Collections.sort(names, (s1, s2) -> s1.compareTo(s2));
 // 或使用方法引用
 Collections.sort(names, String::compareTo);

}
}

函数式接口的实现
Lambda 表达式的目标类型必须是函数式接口——只有一个抽象方法的接口。

java
@FunctionalInterface
interface Calculator {
int calculate(int a, int b);
}

public class FunctionalInterfaceDemo {
public static void main(String[] args) {
// Lambda实现函数式接口
Calculator addition = (a, b) -> a + b;
Calculator subtraction = (a, b) -> a - b;
Calculator multiplication = (a, b) -> a * b;

    System.out.println("10 + 5 = " + addition.calculate(10, 5));
    System.out.println("10 - 5 = " + subtraction.calculate(10, 5));
    System.out.println("10 * 5 = " + multiplication.calculate(10, 5));
    
    // 作为方法参数传递
    processCalculation(addition, 20, 10);
    processCalculation((x, y) -> x / y, 20, 10); // 直接传递Lambda
}

static void processCalculation(Calculator calc, int a, int b) {
    System.out.println("处理结果: " + calc.calculate(a, b));
}

}

集合的批量操作
java
public class CollectionLambda {
public static void main(String[] args) {
List products = Arrays.asList(
new Product(“Laptop”, 999.99, 10),
new Product(“Phone”, 699.99, 25),
new Product(“Tablet”, 399.99, 15),
new Product(“Headphones”, 149.99, 50)
);

 // 传统迭代
 System.out.println("传统迭代:");
 for (Product p : products) {
     if (p.getPrice() > 500) {
         System.out.println(p.getName());
     }
 }
 
 // Lambda迭代
 System.out.println("\nLambda迭代:");
 products.forEach(p -> {
     if (p.getPrice() > 500) {
         System.out.println(p.getName());
     }
 });
 
 // 链式操作
 System.out.println("\n链式操作:");
 products.stream()
         .filter(p -> p.getPrice() > 500)
         .sorted((p1, p2) -> Double.compare(p1.getPrice(), p2.getPrice()))
         .map(p -> p.getName() + ": $" + p.getPrice())
         .forEach(System.out::println);
 
 // 修改集合元素
 System.out.println("\n价格调整:");
 products.replaceAll(p -> {
     if (p.getStock() > 20) {
         p.setPrice(p.getPrice() * 0.9); // 库存多的打9折
     }
     return p;
 });
 
 products.forEach(p -> 
         System.out.println(p.getName() + ": $" + p.getPrice()));

}

static class Product {
String name;
double price;
int stock;

 Product(String name, double price, int stock) {
     this.name = name;
     this.price = price;
     this.stock = stock;
 }
 
 String getName() { return name; }
 double getPrice() { return price; }
 int getStock() { return stock; }
 void setPrice(double price) { this.price = price; }

}
}

Stream API 的核心驱动
java
public class StreamLambda {
public static void main(String[] args) {
List transactions = Arrays.asList(
new Transaction(“USD”, 1000.0, “BUY”),
new Transaction(“EUR”, 800.0, “SELL”),
new Transaction(“USD”, 1500.0, “BUY”),
new Transaction(“GBP”, 1200.0, “BUY”),
new Transaction(“EUR”, 900.0, “SELL”)
);

 // 复杂的业务逻辑处理
 Map<String, Double> buyAmountByCurrency = transactions.stream()
         .filter(t -> "BUY".equals(t.getType()))  // Lambda过滤
         .collect(Collectors.groupingBy(
                 Transaction::getCurrency,         // 方法引用分组
                 Collectors.summingDouble(t -> t.getAmount())  // Lambda求和
         ));
 
 System.out.println("买入交易按货币统计:");
 buyAmountByCurrency.forEach((currency, amount) -> 
         System.out.printf("%s: $%.2f%n", currency, amount));
 
 // 并行处理
 double totalAmount = transactions.parallelStream()
         .mapToDouble(t -> t.getAmount())  // Lambda提取金额
         .sum();
 
 System.out.printf("总交易额: $%.2f%n", totalAmount);

}

static class Transaction {
String currency;
double amount;
String type;

 Transaction(String currency, double amount, String type) {
     this.currency = currency;
     this.amount = amount;
     this.type = type;
 }
 
 String getCurrency() { return currency; }
 double getAmount() { return amount; }
 String getType() { return type; }

}
}
Lambda 的变量捕获
Lambda 表达式可以捕获外部变量，但有一些限制：

java
public class VariableCapture {
public static void main(String[] args) {
final String constant = “常量”; // 必须声明为final或 effectively final
int effectivelyFinal = 42; // effectively final - 初始化后不再修改

    // 可以捕获局部变量
    Runnable r1 = () -> System.out.println(constant + ": " + effectivelyFinal);
    r1.run();
    
    // 不能修改捕获的变量
    // effectivelyFinal = 50;  // 取消注释会导致编译错误
    
    // 可以捕获实例变量（无限制）
    VariableCapture instance = new VariableCapture();
    instance.captureInstanceVariable();
    
    // 可以捕获静态变量（无限制）
    Runnable r2 = () -> System.out.println("静态变量: " + staticVar);
    r2.run();
}

private int instanceVar = 100;
private static int staticVar = 200;

void captureInstanceVariable() {
    Runnable r = () -> {
        instanceVar++;  // 可以修改实例变量
        System.out.println("实例变量: " + instanceVar);
    };
    r.run();
}

}
Lambda 表达式 vs 匿名内部类
虽然 Lambda 可以替代很多匿名内部类的场景，但两者有本质区别：

java
public class LambdaVsAnonymous {
public static void main(String[] args) {
// 1. 作用域不同
String outerVar = “外部变量”;

    // 匿名内部类 - 有自己的作用域
    Runnable anonymous = new Runnable() {
        String innerVar = "内部变量";
        
        @Override
        public void run() {
            String innerVar = "局部变量";  // 可以定义同名变量
            System.out.println(outerVar);
            System.out.println(this.innerVar);  // this指向匿名类实例
        }
    };
    
    // Lambda - 共享外部作用域
    Runnable lambda = () -> {
        // String outerVar = "重定义";  // 错误：不能重定义外部变量
        System.out.println(outerVar);
        System.out.println(this.toString());  // this指向外部类实例
    };
    
    // 2. 编译方式不同
    System.out.println("匿名类类型: " + anonymous.getClass());
    System.out.println("Lambda类型: " + lambda.getClass());
    
    // 3. 性能差异（Lambda通常更高效）
    performanceComparison();
}

static void performanceComparison() {
    int iterations = 1000000;
    
    // 匿名内部类
    long start = System.nanoTime();
    for (int i = 0; i < iterations; i++) {
        Runnable r = new Runnable() {
            @Override
            public void run() {
                // 空操作
            }
        };
    }
    long anonymousTime = System.nanoTime() - start;
    
    // Lambda表达式
    start = System.nanoTime();
    for (int i = 0; i < iterations; i++) {
        Runnable r = () -> {};
    }
    long lambdaTime = System.nanoTime() - start;
    
    System.out.printf("匿名类: %d ns%n", anonymousTime);
    System.out.printf("Lambda: %d ns%n", lambdaTime);
    System.out.printf("性能提升: %.1f%%%n", 
            (double)(anonymousTime - lambdaTime) / anonymousTime * 100);
}

}
实战：用 Lambda 重构传统代码
java
public class LegacyCodeRefactoring {
// 重构前：命令式编程风格
public List getActiveUserNames(List users) {
List activeNames = new ArrayList<>();
for (User user : users) {
if (user.isActive() && user.getAge() >= 18) {
String fullName = user.getFirstName() + “ “ + user.getLastName();
activeNames.add(fullName.toUpperCase());
}
}
Collections.sort(activeNames);
return activeNames;
}

// 重构后：声明式编程风格
public List<String> getActiveUserNamesLambda(List<User> users) {
    return users.stream()
            .filter(User::isActive)                    // 过滤活跃用户
            .filter(user -> user.getAge() >= 18)       // 过滤成年用户
            .map(user -> user.getFirstName() + " " + user.getLastName()) // 拼接全名
            .map(String::toUpperCase)                  // 转为大写
            .sorted()                                  // 排序
            .collect(Collectors.toList());             // 收集结果
}

// 更复杂的业务逻辑重构
public Map<String, Double> calculateDepartmentStats(List<Employee> employees) {
    // 传统方式
    Map<String, List<Employee>> deptMap = new HashMap<>();
    for (Employee emp : employees) {
        String dept = emp.getDepartment();
        deptMap.computeIfAbsent(dept, k -> new ArrayList<>()).add(emp);
    }
    
    Map<String, Double> stats = new HashMap<>();
    for (Map.Entry<String, List<Employee>> entry : deptMap.entrySet()) {
        double totalSalary = 0;
        for (Employee emp : entry.getValue()) {
            totalSalary += emp.getSalary();
        }
        stats.put(entry.getKey(), totalSalary / entry.getValue().size());
    }
    return stats;
    
    // Lambda方式（一行代码替代上面所有逻辑）
    // return employees.stream()
    //         .collect(Collectors.groupingBy(
    //                 Employee::getDepartment,
    //                 Collectors.averagingDouble(Employee::getSalary)
    //         ));
}

static class User {
    boolean active;
    int age;
    String firstName;
    String lastName;
    
    boolean isActive() { return active; }
    int getAge() { return age; }
    String getFirstName() { return firstName; }
    String getLastName() { return lastName; }
}

static class Employee {
    String department;
    double salary;
    
    String getDepartment() { return department; }
    double getSalary() { return salary; }
}

}
Lambda 最佳实践

保持简短和专注
java
// 不好：过于复杂的Lambda
list.forEach(item -> {
// 几十行代码
processStep1(item);
processStep2(item);
processStep3(item);
// …
});

// 好：提取为方法
list.forEach(this::processItem);

private void processItem(Item item) {
processStep1(item);
processStep2(item);
processStep3(item);
}

使用方法引用增强可读性
java
// Lambda表达式
users.stream().map(user -> user.getName())

// 方法引用（更清晰）
users.stream().map(User::getName)

避免副作用
java
// 不好：有副作用
List result = new ArrayList<>();
list.stream()
.filter(s -> s.length() > 3)
.forEach(s -> result.add(s)); // 修改外部状态

// 好：无副作用
List result = list.stream()
.filter(s -> s.length() > 3)
.collect(Collectors.toList());

合理使用类型推断
java
// 不需要显式声明类型（编译器能推断）
Comparator comparator = (s1, s2) -> s1.compareTo(s2);

// 只有在需要时才声明类型
BinaryOperator add = (Long x, Long y) -> x + y;
Lambda 调试技巧
Lambda 表达式调试相对困难，但有一些技巧：

java
public class LambdaDebugging {
public static void main(String[] args) {
List numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

    // 技巧1：使用peek()查看中间结果
    List<Integer> result = numbers.stream()
            .peek(n -> System.out.println("原始: " + n))
            .filter(n -> n % 2 == 0)
            .peek(n -> System.out.println("过滤后: " + n))
            .map(n -> n * 2)
            .peek(n -> System.out.println("转换后: " + n))
            .collect(Collectors.toList());
    
    // 技巧2：将复杂Lambda提取为方法
    numbers.stream()
            .filter(LambdaDebugging::isPrime)  // 提取到方法，方便调试
            .forEach(System.out::println);
    
    // 技巧3：使用临时变量
    numbers.forEach(n -> {
        int squared = n * n;      // 使用临时变量
        System.out.println(n + " 的平方是 " + squared);
    });
}

static boolean isPrime(int n) {
    // 这里可以设置断点调试
    if (n <= 1) return false;
    for (int i = 2; i <= Math.sqrt(n); i++) {
        if (n % i == 0) return false;
    }
    return true;
}

}
总结
Lambda 表达式是 Java 8 最强大的特性之一，它：

简化代码：减少样板代码，让逻辑更清晰

促进函数式编程：支持将函数作为一等公民

提升表达能力：用更少的代码表达复杂的逻辑

增强API设计：使 Stream API 等现代API成为可能

掌握 Lambda 表达式的关键在于理解其本质——匿名函数的简洁表示，并学会在适当的场景中使用它。随着熟练度的提高，你会发现 Lambda
能让你的代码更加优雅、简洁和强大。

记住：Lambda 不是万能的，在复杂逻辑或需要重用的情况下，还是应该使用传统方法或提取为独立方法。合理使用
Lambda，让它成为你编程工具箱中的利器，而不是负担。