Lambda 表达式

// 传统写法：匿名内部类
List<Employee> highSalaryEmployees = new ArrayList<>();
for (Employee emp : allEmployees) {
    if (emp.getSalary() > 15000) {
        highSalaryEmployees.add(emp);
    }
}

// JDK 8 写法：Lambda 表达式
List<Employee> highSalaryEmployees = allEmployees.stream()
    .filter(emp -> emp.getSalary() > 15000)
    .collect(Collectors.toList());

// 写法1：无参数，无返回值
Runnable r1 = () -> System.out.println("Hello Lambda");

// 写法2：单参数，省略类型和括号
Consumer<String> c1 = s -> System.out.println(s);

// 写法3：单参数，保留类型和括号
Consumer<String> c2 = (String s) -> System.out.println(s);

// 写法4：多参数，有返回值，单行省略 return
Comparator<Integer> comp = (a, b) -> a - b;

// 写法5：多参数，多行方法体
BinaryOperator<Integer> add = (a, b) -> {
    int result = a + b;
    System.out.println("计算结果: " + result);
    return result;
};

// 写法6：参数为空的 Supplier
Supplier<Employee> empSupplier = () -> new Employee("默认员工", 0, "未知部门");

@FunctionalInterface  // 编译期校验：确保接口只有一个抽象方法
public interface Predicate<T> {
    boolean test(T t);  // 唯一的抽象方法
    
    // 默认方法不算抽象方法
    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }
    
    // 静态方法也不算
    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
            ? Objects::isNull
            : object -> targetRef.equals(object);
    }
    
    // Object 类的方法也不算（equals, hashCode, toString 等）
    boolean equals(Object obj);
}

// 场景：筛选薪资 > 15000 的员工
Predicate<Employee> highSalary = emp -> emp.getSalary() > 15000;

// 组合使用：薪资高 AND 技术部门
Predicate<Employee> isTech = emp -> "技术部".equals(emp.getDepartment());
Predicate<Employee> highSalaryInTech = highSalary.and(isTech);

boolean result = highSalaryInTech.test(new Employee("小崔", 18000, "技术部"));
// result = true

// 场景：打印员工信息
Consumer<Employee> printEmployee = emp -> 
    System.out.printf("姓名: %s, 薪资: %.2f, 部门: %s%n", 
        emp.getName(), emp.getSalary(), emp.getDepartment());

// 链式消费：先打印，再记录日志
Consumer<Employee> logEmployee = emp -> 
    Logger.log("处理员工: " + emp.getName());
Consumer<Employee> printAndLog = printEmployee.andThen(logEmployee);

// 场景：从员工对象中提取姓名
Function<Employee, String> extractName = Employee::getName;

// 场景：计算员工的年终奖（薪资 * 绩效系数）
Function<Employee, Double> calcBonus = emp -> emp.getSalary() * emp.getPerformanceRate();

// 链式组合：先提取姓名，再转大写
Function<Employee, String> upperName = extractName.andThen(String::toUpperCase);

// 场景：懒加载创建默认员工
Supplier<Employee> defaultEmployee = () -> new Employee("待分配", 0, "未知部门");

// 场景：生成唯一 ID
Supplier<String> idGenerator = () -> "EMP-" + UUID.randomUUID().toString().substring(0, 8);

// 匿名内部类版本
public class AnonymousInnerDemo {
    public static void main(String[] args) {
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello from Anonymous Inner Class");
            }
        };
        r.run();
    }
}

// Lambda 版本
public class LambdaDemo {
    public static void main(String[] args) {
        Runnable r = () -> System.out.println("Hello from Lambda");
        r.run();
    }
}

public class ThisReferenceDemo {
    private String name = "外部类";

    public void testAnonymousInner() {
        // 匿名内部类中的 this 指向内部类自身
        Runnable r = new Runnable() {
            private String name = "匿名内部类";
            @Override
            public void run() {
                System.out.println(this.name);  // 输出: "匿名内部类"
            }
        };
        r.run();
    }

    public void testLambda() {
        // Lambda 中的 this 指向外层类
        Runnable r = () -> {
            System.out.println(this.name);  // 输出: "外部类"
            // this 在这里就是 ThisReferenceDemo 的实例
        };
        r.run();
    }
}

import java.time.LocalDate;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

/**
 * 员工实体类
 */
class Employee {
    private String name;
    private double salary;
    private String department;
    private LocalDate hireDate;

    public Employee(String name, double salary, String department, LocalDate hireDate) {
        this.name = name;
        this.salary = salary;
        this.department = department;
        this.hireDate = hireDate;
    }

    public String getName() { return name; }
    public double getSalary() { return salary; }
    public String getDepartment() { return department; }
    public LocalDate getHireDate() { return hireDate; }

    @Override
    public String toString() {
        return String.format("Employee{name='%s', salary=%.0f, dept='%s', hired=%s}",
                name, salary, department, hireDate);
    }
}

/**
 * 员工筛选器 —— 使用内置函数式接口实现行为参数化
 */
class EmployeeFilter {
    /**
     * 通用筛选方法：将筛选条件作为参数传入
     */
    public static List<Employee> filter(List<Employee> employees, 
                                         Predicate<Employee> condition) {
        List<Employee> result = new ArrayList<>();
        for (Employee emp : employees) {
            if (condition.test(emp)) {
                result.add(emp);
            }
        }
        return result;
    }

    /**
     * 通用处理：对筛选结果执行操作
     */
    public static void process(List<Employee> employees,
                                Predicate<Employee> filter,
                                Consumer<Employee> action) {
        for (Employee emp : employees) {
            if (filter.test(emp)) {
                action.accept(emp);
            }
        }
    }
}

public class LambdaEmployeeDemo {
    public static void main(String[] args) {
        // 准备数据
        List<Employee> employees = new ArrayList<>();
        employees.add(new Employee("大翔", 50000, "管理层", LocalDate.of(2015, 3, 1)));
        employees.add(new Employee("白歌", 35000, "技术部", LocalDate.of(2017, 6, 15)));
        employees.add(new Employee("小崔", 18000, "技术部", LocalDate.of(2021, 7, 1)));
        employees.add(new Employee("孔蓝", 12000, "技术部", LocalDate.of(2023, 9, 1)));
        employees.add(new Employee("老刘", 9000, "后勤部", LocalDate.of(2018, 1, 10)));

        // === 场景1：筛选薪资 > 15000 的员工 ===
        Predicate<Employee> highSalary = emp -> emp.getSalary() > 15000;
        List<Employee> highSalaryEmps = EmployeeFilter.filter(employees, highSalary);
        System.out.println("=== 薪资 > 15000 的员工 ===");
        highSalaryEmps.forEach(System.out::println);

        // === 场景2：组合条件：技术部 AND 入职超过2年 ===
        Predicate<Employee> inTech = emp -> "技术部".equals(emp.getDepartment());
        Predicate<Employee> hiredBefore2Years = emp -> 
            emp.getHireDate().isBefore(LocalDate.now().minusYears(2));
        Predicate<Employee> techVeteran = inTech.and(hiredBefore2Years);

        System.out.println("\n=== 技术部老员工（入职 > 2年） ===");
        List<Employee> techVeterans = EmployeeFilter.filter(employees, techVeteran);
        techVeterans.forEach(System.out::println);

        // === 场景3：使用 Consumer 链式处理 ===
        System.out.println("\n=== 打印 + 计算年终奖 ===");
        Consumer<Employee> printer = emp -> System.out.printf("姓名: %s, 薪资: %.0f%n", 
            emp.getName(), emp.getSalary());
        Consumer<Employee> bonusCalc = emp -> {
            double bonus = emp.getSalary() * 12 * 0.15;  // 15% 年终奖
            System.out.printf("  → 预估年终奖: %.0f%n", bonus);
        };

        EmployeeFilter.process(employees, 
            emp -> emp.getSalary() > 10000, 
            printer.andThen(bonusCalc));

        // === 场景4：Function 提取 + Supplier 默认值 ===
        Function<Employee, String> nameExtractor = Employee::getName;
        Supplier<Employee> defaultEmp = () -> new Employee("默认员工", 0, "无", LocalDate.now());

        System.out.println("\n=== 员工姓名列表 ===");
        employees.stream()
            .map(nameExtractor)
            .forEach(System.out::println);
    }
}

/**
 * 自定义函数式接口 —— 薪资计算策略
 */
@FunctionalInterface
interface SalaryStrategy {
    /**
     * 根据基础薪资计算实际发放金额
     * @param baseSalary 基础月薪
     * @return 实际发放金额
     */
    double calculate(double baseSalary);

    // 默认方法：策略组合
    default SalaryStrategy withBonus(double bonusRate) {
        return baseSalary -> calculate(baseSalary) * (1 + bonusRate);
    }
}

public class SalaryStrategyDemo {
    public static void main(String[] args) {
        double baseSalary = 20000;  // 基础月薪

        // === 策略1：标准月薪（不扣除） ===
        SalaryStrategy standard = salary -> salary;
        System.out.printf("标准月薪: %.2f%n", standard.calculate(baseSalary));

        // === 策略2：扣除五险一金（假设扣 22%） ===
        SalaryStrategy afterInsurance = salary -> salary * 0.78;
        System.out.printf("扣除五险一金后: %.2f%n", afterInsurance.calculate(baseSalary));

        // === 策略3：含年终奖（15%）的折算月薪 ===
        SalaryStrategy withBonus = standard.withBonus(0.15);
        System.out.printf("含15%%年终奖: %.2f%n", withBonus.calculate(baseSalary));

        // === 策略4：组合：先扣保险，再加奖金 ===
        SalaryStrategy netWithBonus = afterInsurance.withBonus(0.15);
        System.out.printf("扣除保险+含奖金: %.2f%n", netWithBonus.calculate(baseSalary));

        // === 使用策略列表进行批量计算 ===
        System.out.println("\n=== 批量薪资计算 ===");
        double[] salaries = {12000, 18000, 35000, 50000};
        for (double s : salaries) {
            double actual = netWithBonus.calculate(s);
            System.out.printf("月薪 %8.0f → 实发 %8.2f (税率: %.0f%%)%n",
                s, actual, (1 - actual / s) * 100);
        }
    }
}

// 静态方法引用
Function<String, Integer> parser = Integer::parseInt;          // 等效: s -> Integer.parseInt(s)

// 实例方法引用（特定对象）
String prefix = "EMP-";
Function<String, String> addPrefix = prefix::concat;           // 等效: s -> prefix.concat(s)

// 实例方法引用（类名）
Function<Employee, String> getName = Employee::getName;        // 等效: emp -> emp.getName()

// 构造方法引用
Supplier<Employee> empFactory = Employee::new;                 // 等效: () -> new Employee()
Function<String, Employee> namedEmp = Employee::new;           // 等效: name -> new Employee(name)

// ❌ 错误：Lambda 中不能修改外部局部变量
int count = 0;
List<Employee> employees = getEmployees();
employees.forEach(emp -> {
    if (emp.getSalary() > 15000) {
        count++;  // 编译错误：Variable used in lambda should be final or effectively final
    }
});
System.out.println("高薪员工数: " + count);

// ✅ 正确：使用原子类或 Stream 的 count() 方法
long count = employees.stream()
    .filter(emp -> emp.getSalary() > 15000)
    .count();
System.out.println("高薪员工数: " + count);

// ✅ 或者使用数组装一层（但不推荐，仅是变通方案）
int[] counter = {0};
employees.forEach(emp -> {
    if (emp.getSalary() > 15000) {
        counter[0]++;  // 数组元素可以修改
    }
});

// ❌ 错误：Lambda 中抛出的受检异常无法传播
employees.forEach(emp -> {
    // 编译错误：Unhandled exception: IOException
    Files.write(Paths.get("employee.txt"), emp.toString().getBytes());
});

// ✅ 正确：在 Lambda 内部 try-catch
employees.forEach(emp -> {
    try {
        Files.write(Paths.get("employee.txt"), 
            (emp.toString() + "\n").getBytes(), StandardOpenOption.APPEND);
    } catch (IOException e) {
        throw new UncheckedIOException(e);  // 包装为非受检异常
    }
});

// ✅ 更好：抽取方法并处理异常
private static Consumer<Employee> safeWriter(Path path) {
    return emp -> {
        try {
            Files.write(path, (emp.toString() + "\n").getBytes(), StandardOpenOption.APPEND);
        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }
    };
}

// ❌ 错误：不能直接将 Lambda 赋值给 Object
Object obj = () -> System.out.println("Hello");  // 编译错误：Target type of lambda must be an interface

// ✅ 正确：先赋值给函数式接口，再赋值给 Object
Runnable r = () -> System.out.println("Hello");
Object obj = (Object) r;  // 需要强制转型

// ❌ 错误：Lambda 嵌套过深，可读性极差
employees.stream()
    .filter(e -> e.getDepartment().equals("技术部"))
    .map(e -> {
        return new Object() {
            String name = e.getName();
            double bonus = e.getSalary() * 0.15;
        };
    })
    .collect(Collectors.groupingBy(
        o -> o.bonus > 5000 ? "高奖金" : "低奖金",
        Collectors.mapping(o -> o.name, Collectors.toList())
    ));

// ✅ 正确：抽取中间变量和方法，保持可读性
Predicate<Employee> isTech = e -> "技术部".equals(e.getDepartment());
Function<Employee, BonusInfo> toBonusInfo = e -> 
    new BonusInfo(e.getName(), e.getSalary() * 0.15);
Function<BonusInfo, String> bonusLevel = b -> b.bonus > 5000 ? "高奖金" : "低奖金";

Map<String, List<String>> result = employees.stream()
    .filter(isTech)
    .map(toBonusInfo)
    .collect(Collectors.groupingBy(bonusLevel,
        Collectors.mapping(BonusInfo::getName, Collectors.toList())));