Java Lambda表达式详解

Lambda基础语法

// 无参数无返回值
Runnable r = () -> System.out.println("Hello Lambda");

// 有参数无返回值
Consumer<String> printer = s -> System.out.println(s);

// 有参数有返回值
Function<String, Integer> lengthFunc = s -> s.length();

// 多行lambda
Function<String, String> processor = s -> {
    String trimmed = s.trim();
    return trimmed.toLowerCase();
};

函数式接口

// JDK内置函数式接口
@FunctionalInterface
public interface MyFunction<T, R> {
    R apply(T t);
}

// Predicate：断言，返回boolean
Predicate<Integer> isPositive = n -> n > 0;
System.out.println(isPositive.test(5));  // true

// Function：转换
Function<String, Integer> toLength = String::length;
System.out.println(toLength.apply("hello"));  // 5

// Consumer：消费
Consumer<String> print = System.out::println;
print.accept("hello");

// Supplier：提供
Supplier<Double> random = Math::random;
System.out.println(random.get());

// UnaryOperator：一元操作
UnaryOperator<String> upper = String::toUpperCase;
System.out.println(upper.apply("hello"));  // HELLO

// BinaryOperator：二元操作
BinaryOperator<Integer> add = Integer::sum;
System.out.println(add.apply(1, 2));  // 3

方法引用

public class MethodRefDemo {
    // 静态方法引用：ClassName::staticMethod
    Function<String, Integer> parseInt = Integer::parseInt;

    // 实例方法引用：instance::method
    String str = "hello";
    Supplier<Integer> lengthSupplier = str::length;

    // 特定对象的实例方法引用：ClassName::methodName
    Function<String, Integer> strLength = String::length;

    // 构造器引用：ClassName::new
    Supplier<ArrayList<String>> listFactory = ArrayList::new;
    Function<String, StringBuilder> sbFactory = StringBuilder::new;

    public static void main(String[] args) {
        List<String> names = List.of("Alice", "Bob", "Charlie");

        // 使用方法引用替代lambda
        List<Integer> lengths = names.stream()
            .map(String::length)     // 方法引用
            .toList();

        List<String> upper = names.stream()
            .map(String::toUpperCase) // 方法引用
            .toList();
    }
}

Lambda实际应用

集合操作

public class LambdaCollections {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(5, 3, 8, 1, 9, 2, 7);

        // 排序
        List<Integer> sorted = numbers.stream()
            .sorted((a, b) -> b - a)  // 降序
            .toList();
        // [9, 8, 7, 5, 3, 2, 1]

        // 过滤并转换
        List<String> result = numbers.stream()
            .filter(n -> n % 2 == 0)
            .map(n -> "偶数: " + n)
            .toList();

        // 归约
        int sum = numbers.stream()
            .reduce(0, Integer::sum);

        // 收集到Map
        Map<Boolean, List<Integer>> partitioned = numbers.stream()
            .collect(Collectors.partitioningBy(n -> n > 5));
    }
}

事件处理

public class EventDemo {
    public static void main(String[] args) {
        JButton button = new JButton("Click me");

        // Lambda简化事件处理
        button.addActionListener(e ->
            System.out.println("按钮被点击")
        );

        // 多行lambda
        button.addActionListener(e -> {
            System.out.println("按钮被点击");
            updateUI();
            sendNotification();
        });
    }
}

自定义函数式接口

@FunctionalInterface
public interface Transformer<T> {
    T transform(T input);

    default Transformer<T> andThen(Transformer<T> after) {
        return input -> after.transform(this.transform(input));
    }
}

// 使用
Transformer<String> trim = String::trim;
Transformer<String> lower = String::toLowerCase;
Transformer<String> process = trim.andThen(lower);

System.out.println(process.transform("  Hello  "));  // "hello"

异步回调

@FunctionalInterface
public interface AsyncCallback<T> {
    void onSuccess(T result);
    void onError(Throwable error);
}

public class AsyncService {
    public <T> void executeAsync(Supplier<T> task, AsyncCallback<T> callback) {
        new Thread(() -> {
            try {
                T result = task.get();
                callback.onSuccess(result);
            } catch (Exception e) {
                callback.onError(e);
            }
        }).start();
    }
}

// 使用
AsyncService service = new AsyncService();
service.executeAsync(
    () -> fetchDataFromDB(),
    new AsyncCallback<>() {
        @Override
        public void onSuccess(String result) {
            System.out.println("成功: " + result);
        }
        @Override
        public void onError(Throwable error) {
            System.out.println("失败: " + error.getMessage());
        }
    }
);

Lambda与Optional结合

public class OptionalLambda {
    public static void main(String[] args) {
        Optional<String> name = Optional.of("Alice");

        // ifPresent + lambda
        name.ifPresent(n -> System.out.println("名字: " + n));

        // map + lambda
        Optional<Integer> length = name.map(String::length);

        // orElse + lambda
        String result = name.orElse("Unknown");

        // 链式操作
        String greeting = Optional.ofNullable(getUser())
            .map(User::getName)
            .map("Hello, "::concat)
            .orElse("Hello, Guest");
    }
}

Lambda性能优化

public class LambdaPerformance {
    // 不推荐：每次调用都创建新的lambda实例
    public void bad() {
        numbers.stream()
            .filter(n -> n > 0)  // 每次创建新实例
            .toList();
    }

    // 推荐：将lambda提取为常量
    private static final Predicate<Integer> IS_POSITIVE = n -> n > 0;

    public void good() {
        numbers.stream()
            .filter(IS_POSITIVE)  // 复用同一个实例
            .toList();
    }
}

总结

Lambda表达式是Java 8最重要的特性之一，配合函数式接口可以写出简洁、声明式的代码。掌握方法引用和函数式接口是高效使用Lambda的关键。