java中的Lambda表达式使用及说明

// 1. 传统匿名内部类（冗余）
new Thread(new Runnable() {
    @Override
    public void run() { // 唯一抽象方法
        System.out.println("匿名内部类执行线程任务");
    }
}).start();

// 2. Lambda 表达式（简洁）
new Thread(() -> System.out.println("Lambda 执行线程任务")).start();

// 匿名内部类：“完整快递箱”，冗余代码多
List<Integer> list = Arrays.asList(3,1,2);
Collections.sort(list, new Comparator<Integer>() {
    @Override
    public int compare(Integer a, Integer b) {
        return a - b; // 核心逻辑：“书”
    }
});

// Lambda：“裸奔快递”，只留核心逻辑
list.sort((a, b) -> a - b);

List<String> fruits = Arrays.asList("苹果", "香蕉", "橙子", "小番茄");
// 传递“长度>2”这个行为给 filter 方法
List<String> longFruits = fruits.stream()
                               .filter(f -> f.length() > 2) // Lambda：传递“过滤行为”
                               .collect(Collectors.toList());

// Lambda 写法：“口头指示”快递员
list.sort((s1, s2) -> s1.length() - s2.length());

// 方法引用写法：“直接写收件人”，更简洁
list.sort(Comparator.comparingInt(String::length));

// 错误：未处理 checked 异常
List<File> files = Arrays.asList(new File("a.txt"), new File("b.txt"));
files.stream().map(file -> file.getCanonicalPath()); // getCanonicalPath 抛出 IOException

// 正确：要么 try-catch，要么声明异常
files.stream().map(file -> {
    try {
        return file.getCanonicalPath();
    } catch (IOException e) {
        throw new RuntimeException(e); // 转为 unchecked 异常
    }
});

// 原始 Lambda（无简化）
Comparator<Integer> comp1 = (Integer a, Integer b) -> {
    return b - a; // 降序排序
};

// 简化1：省略参数类型（Java 自动推断）
Comparator<Integer> comp2 = (a, b) -> {
    return b - a;
};

// 简化2：单返回语句省略大括号和 return
Comparator<Integer> comp3 = (a, b) -> b - a;

// 最终简化结果（Stream 中直接使用）
List<Integer> list = Arrays.asList(3,1,2);
list.stream().sorted((a, b) -> b - a).forEach(System.out::println); // 输出 3,2,1

List<Employee> empList = Arrays.asList(
    new Employee("张三", 28, 15000),
    new Employee("李四", 32, 18000),
    new Employee("赵六", 35, 20000)
);

// 需求：筛选30岁以上员工 → 提取姓名 → 按姓名长度降序 → 打印
empList.stream()
    .filter(emp -> emp.getAge() >= 30) // Predicate：筛选条件
    .map(Employee::getName) // Function：提取姓名（方法引用简化Lambda）
    .sorted((name1, name2) -> name2.length() - name1.length()) // Comparator：排序
    .forEach(System.out::println); // Consumer：打印

// 输出：赵六（2字）、李四（2字）（若有3字姓名会排在前面）

// 1. 实例方法引用（对象）：System.out::println 替代 (s) -> System.out.println(s)
List<String> names = Arrays.asList("张三", "李四");
names.stream().forEach(System.out::println);

// 2. 实例方法引用（参数）：String::length 替代 (s) -> s.length()
List<Integer> nameLengths = names.stream()
    .map(String::length) // 提取姓名长度
    .collect(Collectors.toList());

// 3. 构造器引用：ArrayList::new 替代 () -> new ArrayList<>()
List<String> newNames = names.stream()
    .filter(name -> name.length() == 2)
    .collect(Collectors.toCollection(ArrayList::new));

// 正确：外部变量是 effectively final（声明后未修改）
int minAge = 30;
empList.stream().filter(emp -> emp.getAge() >= minAge).forEach(System.out::println);

// 错误：修改外部变量（编译报错）
int count = 0;
empList.stream().forEach(emp -> {
    count++; // 报错：Variable used in lambda expression should be final or effectively final
});

// 错误：Lambda 中抛出受检异常，未处理
List<String> files = Arrays.asList("a.txt", "b.txt");
files.stream().map(file -> new FileInputStream(file)); // 编译报错：未处理 IOException

// 正确：捕获异常
files.stream().map(file -> {
    try {
        return new FileInputStream(file);
    } catch (IOException e) {
        throw new RuntimeException(e); // 转为运行时异常抛出
    }
});