Java Lambda 表达式从入门到实战彻底搞懂函数式编程

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
public class LambdaDemo {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "cherry");
        // 匿名内部类实现Comparator接口
        Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                // 按字符串长度升序排序
                return Integer.compare(s1.length(), s2.length());
            }
        });
        System.out.println(list); // 输出：[apple, banana, cherry]
    }
}

import java.util.Arrays;
import java.util.List;
public class LambdaDemo {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "cherry");
        // Lambda表达式简化行为传递
        Collections.sort(list, (s1, s2) -> Integer.compare(s1.length(), s2.length()));
        System.out.println(list); // 输出：[apple, banana, cherry]
    }
}

// 用@FunctionalInterface注解声明函数式接口
@FunctionalInterface
public interface MyFunction {
    // 只包含一个抽象方法
    int calculate(int a, int b);
    // 允许包含默认方法（Java 8新特性，非抽象方法）
    default void printResult(int result) {
        System.out.println("计算结果：" + result);
    }
    // 允许包含静态方法（非抽象方法）
    static boolean isPositive(int num) {
        return num > 0;
    }
}

(参数列表) -> { 方法体 }

public class LambdaSyntaxDemo {
    public static void main(String[] args) {
        // 1. 完整语法：多个参数、显式类型、带return的方法体
        MyFunction add1 = (int a, int b) -> {
            int sum = a + b;
            return sum; // 方法体多行时，return和{}不能省略
        };
        add1.printResult(add1.calculate(2, 3)); // 输出：计算结果：5
        // 2. 简化语法1：省略参数类型（编译器推断）
        MyFunction add2 = (a, b) -> {
            int sum = a + b;
            return sum;
        };
        add2.printResult(add2.calculate(4, 5)); // 输出：计算结果：9
        // 3. 简化语法2：省略{}和return（方法体只有return语句）
        MyFunction add3 = (a, b) -> a + b;
        add3.printResult(add3.calculate(6, 7)); // 输出：计算结果：13
        // 4. 其他场景：参数为对象
        MyFunction max = (a, b) -> a > b ? a : b;
        max.printResult(max.calculate(10, 8)); // 输出：计算结果：10
    }
}

import java.util.Arrays;
import java.util.List;
public class LambdaCollectionDemo {
    public static void main(String[] args) {
        List<String> fruits = Arrays.asList("apple", "banana", "cherry", "date");
        // 场景1：遍历集合（替代for循环或迭代器）
        System.out.println("遍历集合：");
        fruits.forEach(fruit -> System.out.println(fruit));
        // 场景2：排序（按字符串长度降序）
        fruits.sort((f1, f2) -> Integer.compare(f2.length(), f1.length()));
        System.out.println("\n按长度降序排序：" + fruits); // 输出：[banana, cherry, apple, date]
        // 场景3：结合Stream过滤（筛选长度>5的水果）
        System.out.println("\n长度>5的水果：");
        fruits.stream()
              .filter(fruit -> fruit.length() > 5) // Lambda作为过滤条件
              .forEach(fruit -> System.out.println(fruit)); // 输出：banana, cherry
    }
}

public class LambdaThreadDemo {
    public static void main(String[] args) {
        // 传统方式：匿名内部类
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("传统线程：Hello Thread1");
            }
        });
        thread1.start();
        // Lambda方式：简化Runnable实现
        Thread thread2 = new Thread(() -> System.out.println("Lambda线程：Hello Thread2"));
        thread2.start();
    }
}

public class LambdaStrategyDemo {
    // 方法接收函数式接口作为参数（策略）
    public static int calculate(int a, int b, MyFunction strategy) {
        return strategy.calculate(a, b);
    }
    public static void main(String[] args) {
        // 1. 传递“加法”策略
        int sum = calculate(10, 5, (x, y) -> x + y);
        System.out.println("加法结果：" + sum); // 输出：15
        // 2. 传递“减法”策略
        int difference = calculate(10, 5, (x, y) -> x - y);
        System.out.println("减法结果：" + difference); // 输出：5
        // 3. 传递“乘法”策略
        int product = calculate(10, 5, (x, y) -> x * y);
        System.out.println("乘法结果：" + product); // 输出：50
    }
}