Lambda表达式深入实战：现代业务场景应用指南（上篇）

// 原始Lambda表达式
Function<String, String> upperCase = s -> s.toUpperCase();

// 编译器生成的等价代码（简化版）
Function<String, String> upperCase = new Function<String, String>() {
    @Override
    public String apply(String s) {
        return s.toUpperCase();
    }
};

// 实际上编译器使用invokedynamic指令和方法句柄
// 这比传统匿名内部类更高效

🔧 编译器优化策略：

• invokedynamic指令：延迟绑定，运行时优化
• 方法句柄：直接方法调用，避免反射开销
• 常量池优化：相同Lambda表达式复用
• 逃逸分析：栈上分配，减少GC压力

🎯 示例1：企业级函数式接口设计

import java.util.function.*;
import java.util.concurrent.CompletableFuture;

/**
 * 业务规则处理器 - 企业级函数式接口设计
 */
public class BusinessRuleProcessor {
    
    // 1. 业务验证器接口
    @FunctionalInterface
    public interface BusinessValidator<T> {
        ValidationResult validate(T data);
        
        // 组合验证器
        default BusinessValidator<T> and(BusinessValidator<T> other) {
            return data -> {
                ValidationResult result1 = this.validate(data);
                if (!result1.isValid()) {
                    return result1;
                }
                return other.validate(data);
            };
        }
        
        // 或逻辑验证器
        default BusinessValidator<T> or(BusinessValidator<T> other) {
            return data -> {
                ValidationResult result1 = this.validate(data);
                if (result1.isValid()) {
                    return result1;
                }
                return other.validate(data);
            };
        }
    }
    
    // 2. 异步业务处理器
    @FunctionalInterface
    public interface AsyncBusinessProcessor<T, R> {
        CompletableFuture<R> processAsync(T input);
        
        // 链式异步处理
        default <V> AsyncBusinessProcessor<T, V> thenProcess(
                AsyncBusinessProcessor<R, V> next) {
            return input -> this.processAsync(input)
                .thenCompose(next::processAsync);
        }
    }
    
    // 3. 条件执行器
    @FunctionalInterface
    public interface ConditionalExecutor<T> {
        void executeIf(T data, Predicate<T> condition);
        
        static <T> ConditionalExecutor<T> of(Consumer<T> action) {
            return (data, condition) -> {
                if (condition.test(data)) {
                    action.accept(data);
                }
            };
        }
    }
    
    // 验证结果类
    public static class ValidationResult {
        private final boolean valid;
        private final String message;
        
        public ValidationResult(boolean valid, String message) {
            this.valid = valid;
            this.message = message;
        }
        
        public boolean isValid() { return valid; }
        public String getMessage() { return message; }
        
        public static ValidationResult success() {
            return new ValidationResult(true, "验证通过");
        }
        
        public static ValidationResult failure(String message) {
            return new ValidationResult(false, message);
        }
    }
}

🔑 关键技术点

• ✅ invokedynamic指令：实现动态方法调用，提升性能
• ✅ 方法句柄：直接方法引用，避免反射开销
• ✅ 函数式接口设计：单一抽象方法 + 默认方法组合
• ✅ 类型推断：编译器自动推断Lambda表达式类型
• ✅ 闭包支持：捕获外部变量，实现函数式编程

🚀 性能优势

• 编译时优化：字节码级别的优化
• 运行时优化：JVM动态优化Lambda调用
• 内存效率：避免创建多余的匿名类实例
• 并发友好：天然支持并行处理

🎯 示例2：电商订单处理链

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.*;
import java.util.function.*;
import java.util.stream.Collectors;

/**
 * 电商订单处理系统 - Lambda表达式实战应用
 */
public class ECommerceOrderProcessor {
    
    // 订单实体
    public static class Order {
        private String orderId;
        private String customerId;
        private List<OrderItem> items;
        private BigDecimal totalAmount;
        private OrderStatus status;
        private LocalDateTime createTime;
        private String couponCode;
        private String customerLevel; // VIP, GOLD, SILVER, NORMAL
        
        // 构造器和getter/setter省略...
        public Order(String orderId, String customerId, List<OrderItem> items, 
                    String couponCode, String customerLevel) {
            this.orderId = orderId;
            this.customerId = customerId;
            this.items = items;
            this.couponCode = couponCode;
            this.customerLevel = customerLevel;
            this.createTime = LocalDateTime.now();
            this.status = OrderStatus.PENDING;
            this.totalAmount = calculateTotal();
        }
        
        private BigDecimal calculateTotal() {
            return items.stream()
                .map(item -> item.getPrice().multiply(BigDecimal.valueOf(item.getQuantity())))
                .reduce(BigDecimal.ZERO, BigDecimal::add);
        }
        
        // getter方法省略...
        public String getOrderId() { return orderId; }
        public String getCustomerId() { return customerId; }
        public List<OrderItem> getItems() { return items; }
        public BigDecimal getTotalAmount() { return totalAmount; }
        public OrderStatus getStatus() { return status; }
        public LocalDateTime getCreateTime() { return createTime; }
        public String getCouponCode() { return couponCode; }
        public String getCustomerLevel() { return customerLevel; }
        
        public void setStatus(OrderStatus status) { this.status = status; }
        public void setTotalAmount(BigDecimal totalAmount) { this.totalAmount = totalAmount; }
    }
    
    public static class OrderItem {
        private String productId;
        private String productName;
        private BigDecimal price;
        private int quantity;
        private String category;
        
        public OrderItem(String productId, String productName, BigDecimal price, 
                        int quantity, String category) {
            this.productId = productId;
            this.productName = productName;
            this.price = price;
            this.quantity = quantity;
            this.category = category;
        }
        
        // getter方法
        public String getProductId() { return productId; }
        public String getProductName() { return productName; }
        public BigDecimal getPrice() { return price; }
        public int getQuantity() { return quantity; }
        public String getCategory() { return category; }
    }
    
    public enum OrderStatus {
        PENDING, CONFIRMED, SHIPPED, DELIVERED, CANCELLED
    }
    
    // 1. 订单验证规则链
    public static class OrderValidationChain {
        
        // 库存验证
        public static final BusinessRuleProcessor.BusinessValidator<Order> STOCK_VALIDATOR = 
            order -> {
                boolean hasStock = order.getItems().stream()
                    .allMatch(item -> checkStock(item.getProductId(), item.getQuantity()));
                return hasStock ? 
                    BusinessRuleProcessor.ValidationResult.success() :
                    BusinessRuleProcessor.ValidationResult.failure("库存不足");
            };
        
        // 价格验证
        public static final BusinessRuleProcessor.BusinessValidator<Order> PRICE_VALIDATOR = 
            order -> {
                BigDecimal minAmount = new BigDecimal("0.01");
                BigDecimal maxAmount = new BigDecimal("50000.00");
                BigDecimal total = order.getTotalAmount();
                
                if (total.compareTo(minAmount) < 0 || total.compareTo(maxAmount) > 0) {
                    return BusinessRuleProcessor.ValidationResult.failure(
                        "订单金额超出允许范围");
                }
                return BusinessRuleProcessor.ValidationResult.success();
            };
        
        // 客户验证
        public static final BusinessRuleProcessor.BusinessValidator<Order> CUSTOMER_VALIDATOR = 
            order -> {
                if (order.getCustomerId() == null || order.getCustomerId().trim().isEmpty()) {
                    return BusinessRuleProcessor.ValidationResult.failure("客户ID不能为空");
                }
                // 模拟客户状态检查
                if (isCustomerBlacklisted(order.getCustomerId())) {
                    return BusinessRuleProcessor.ValidationResult.failure("客户已被列入黑名单");
                }
                return BusinessRuleProcessor.ValidationResult.success();
            };
        
        // 组合验证器
        public static final BusinessRuleProcessor.BusinessValidator<Order> COMPLETE_VALIDATOR = 
            STOCK_VALIDATOR.and(PRICE_VALIDATOR).and(CUSTOMER_VALIDATOR);
        
        private static boolean checkStock(String productId, int quantity) {
            // 模拟库存检查
            return Math.random() > 0.1; // 90%概率有库存
        }
        
        private static boolean isCustomerBlacklisted(String customerId) {
            // 模拟黑名单检查
            return customerId.contains("blacklist");
        }
    }
    
    // 2. 优惠计算策略
    public static class DiscountCalculator {
        
        // 优惠策略函数
        public static final Function<Order, BigDecimal> VIP_DISCOUNT = 
            order -> "VIP".equals(order.getCustomerLevel()) ? 
                order.getTotalAmount().multiply(new BigDecimal("0.15")) : BigDecimal.ZERO;
        
        public static final Function<Order, BigDecimal> GOLD_DISCOUNT = 
            order -> "GOLD".equals(order.getCustomerLevel()) ? 
                order.getTotalAmount().multiply(new BigDecimal("0.10")) : BigDecimal.ZERO;
        
        public static final Function<Order, BigDecimal> COUPON_DISCOUNT = 
            order -> {
                if (order.getCouponCode() != null && !order.getCouponCode().isEmpty()) {
                    // 模拟优惠券折扣计算
                    return order.getTotalAmount().multiply(new BigDecimal("0.05"));
                }
                return BigDecimal.ZERO;
            };
        
        public static final Function<Order, BigDecimal> BULK_DISCOUNT = 
            order -> {
                int totalItems = order.getItems().stream()
                    .mapToInt(OrderItem::getQuantity)
                    .sum();
                if (totalItems >= 10) {
                    return order.getTotalAmount().multiply(new BigDecimal("0.08"));
                }
                return BigDecimal.ZERO;
            };
        
        // 组合所有优惠策略
        public static BigDecimal calculateTotalDiscount(Order order) {
            return Stream.of(VIP_DISCOUNT, GOLD_DISCOUNT, COUPON_DISCOUNT, BULK_DISCOUNT)
                .map(strategy -> strategy.apply(order))
                .reduce(BigDecimal.ZERO, BigDecimal::add);
        }
    }
    
    // 3. 订单处理流水线
    public static class OrderProcessingPipeline {
        
        // 处理步骤定义
        public static final Function<Order, Order> VALIDATE_ORDER = order -> {
            BusinessRuleProcessor.ValidationResult result = 
                OrderValidationChain.COMPLETE_VALIDATOR.validate(order);
            if (!result.isValid()) {
                throw new RuntimeException("订单验证失败: " + result.getMessage());
            }
            System.out.println("✅ 订单验证通过: " + order.getOrderId());
            return order;
        };
        
        public static final Function<Order, Order> APPLY_DISCOUNTS = order -> {
            BigDecimal discount = DiscountCalculator.calculateTotalDiscount(order);
            BigDecimal finalAmount = order.getTotalAmount().subtract(discount);
            order.setTotalAmount(finalAmount);
            System.out.println("💰 应用优惠: " + order.getOrderId() + 
                             ", 优惠金额: " + discount + ", 最终金额: " + finalAmount);
            return order;
        };
        
        public static final Function<Order, Order> RESERVE_INVENTORY = order -> {
            order.getItems().forEach(item -> {
                System.out.println("📦 预留库存: " + item.getProductName() + 
                                 " x " + item.getQuantity());
            });
            return order;
        };
        
        public static final Function<Order, Order> CONFIRM_ORDER = order -> {
            order.setStatus(OrderStatus.CONFIRMED);
            System.out.println("✅ 订单确认: " + order.getOrderId());
            return order;
        };
        
        // 完整处理流水线
        public static final Function<Order, Order> COMPLETE_PIPELINE = 
            VALIDATE_ORDER
                .andThen(APPLY_DISCOUNTS)
                .andThen(RESERVE_INVENTORY)
                .andThen(CONFIRM_ORDER);
    }
    
    // 演示方法
    public static void main(String[] args) {
        System.out.println("=== 电商订单处理系统演示 ===");
        
        // 创建测试订单
        List<OrderItem> items = Arrays.asList(
            new OrderItem("P001", "iPhone 15", new BigDecimal("6999.00"), 1, "电子产品"),
            new OrderItem("P002", "AirPods Pro", new BigDecimal("1999.00"), 2, "电子产品")
        );
        
        Order order = new Order("ORD001", "CUST001", items, "SAVE10", "VIP");
        
        try {
            // 执行订单处理流水线
            Order processedOrder = OrderProcessingPipeline.COMPLETE_PIPELINE.apply(order);
            System.out.println("\n🎉 订单处理完成!");
            System.out.println("订单ID: " + processedOrder.getOrderId());
            System.out.println("最终金额: " + processedOrder.getTotalAmount());
            System.out.println("订单状态: " + processedOrder.getStatus());
            
        } catch (Exception e) {
            System.err.println("❌ 订单处理失败: " + e.getMessage());
        }
    }
}

💼 业务价值体现

• 🔄 流水线处理：将复杂的订单处理分解为可组合的函数步骤
• 📋 规则验证：使用函数组合实现灵活的业务规则验证
• 💰 策略模式：优惠计算策略的函数式实现
• 🔧 易于扩展：新增处理步骤只需添加新的函数并组合

🚀 技术优势

• 类型安全：编译时检查，减少运行时错误
• 代码复用：函数可以在不同场景中重复使用
• 测试友好：每个函数都可以独立测试
• 性能优化：利用Stream API的延迟计算特性

🎯 示例3：智能商品推荐引擎

import java.util.*;
import java.util.function.*;
import java.util.stream.Collectors;

/**
 * 商品推荐系统 - 基于Lambda表达式的推荐算法实现
 */
public class ProductRecommendationEngine {

    // 商品实体
    public static class Product {
        private String productId;
        private String name;
        private String category;
        private double price;
        private double rating;
        private Set<String> tags;
        private int salesCount;

        public Product(String productId, String name, String category,
                      double price, double rating, Set<String> tags, int salesCount) {
            this.productId = productId;
            this.name = name;
            this.category = category;
            this.price = price;
            this.rating = rating;
            this.tags = tags;
            this.salesCount = salesCount;
        }

        // getter方法
        public String getProductId() { return productId; }
        public String getName() { return name; }
        public String getCategory() { return category; }
        public double getPrice() { return price; }
        public double getRating() { return rating; }
        public Set<String> getTags() { return tags; }
        public int getSalesCount() { return salesCount; }

        @Override
        public String toString() {
            return String.format("Product{id='%s', name='%s', price=%.2f, rating=%.1f}",
                               productId, name, price, rating);
        }
    }

    // 用户行为数据
    public static class UserBehavior {
        private String userId;
        private String productId;
        private String action; // VIEW, CART, PURCHASE
        private long timestamp;

        public UserBehavior(String userId, String productId, String action, long timestamp) {
            this.userId = userId;
            this.productId = productId;
            this.action = action;
            this.timestamp = timestamp;
        }

        public String getUserId() { return userId; }
        public String getProductId() { return productId; }
        public String getAction() { return action; }
        public long getTimestamp() { return timestamp; }
    }

    // 推荐策略接口
    @FunctionalInterface
    public interface RecommendationStrategy {
        List<Product> recommend(String userId, List<Product> allProducts,
                              List<UserBehavior> userBehaviors, int limit);

        // 组合推荐策略
        default RecommendationStrategy combine(RecommendationStrategy other,
                                             double thisWeight, double otherWeight) {
            return (userId, products, behaviors, limit) -> {
                List<Product> thisResult = this.recommend(userId, products, behaviors, limit * 2);
                List<Product> otherResult = other.recommend(userId, products, behaviors, limit * 2);

                // 简单的加权合并逻辑
                Set<Product> combined = new LinkedHashSet<>();
                combined.addAll(thisResult);
                combined.addAll(otherResult);

                return combined.stream().limit(limit).collect(Collectors.toList());
            };
        }
    }

    // 推荐策略实现
    public static class RecommendationStrategies {

        // 1. 基于协同过滤的推荐
        public static final RecommendationStrategy COLLABORATIVE_FILTERING =
            (userId, products, behaviors, limit) -> {
                // 找到相似用户
                Set<String> userProducts = behaviors.stream()
                    .filter(b -> b.getUserId().equals(userId))
                    .filter(b -> "PURCHASE".equals(b.getAction()))
                    .map(UserBehavior::getProductId)
                    .collect(Collectors.toSet());

                // 找到购买了相似商品的其他用户
                Map<String, Long> similarUsers = behaviors.stream()
                    .filter(b -> "PURCHASE".equals(b.getAction()))
                    .filter(b -> !b.getUserId().equals(userId))
                    .filter(b -> userProducts.contains(b.getProductId()))
                    .collect(Collectors.groupingBy(
                        UserBehavior::getUserId,
                        Collectors.counting()
                    ));

                // 推荐相似用户购买的其他商品
                return behaviors.stream()
                    .filter(b -> similarUsers.containsKey(b.getUserId()))
                    .filter(b -> "PURCHASE".equals(b.getAction()))
                    .filter(b -> !userProducts.contains(b.getProductId()))
                    .map(UserBehavior::getProductId)
                    .distinct()
                    .map(productId -> products.stream()
                        .filter(p -> p.getProductId().equals(productId))
                        .findFirst().orElse(null))
                    .filter(Objects::nonNull)
                    .limit(limit)
                    .collect(Collectors.toList());
            };

        // 2. 基于内容的推荐
        public static final RecommendationStrategy CONTENT_BASED =
            (userId, products, behaviors, limit) -> {
                // 分析用户偏好的类别和标签
                Map<String, Long> preferredCategories = behaviors.stream()
                    .filter(b -> b.getUserId().equals(userId))
                    .filter(b -> Arrays.asList("PURCHASE", "CART").contains(b.getAction()))
                    .map(UserBehavior::getProductId)
                    .map(productId -> products.stream()
                        .filter(p -> p.getProductId().equals(productId))
                        .findFirst().orElse(null))
                    .filter(Objects::nonNull)
                    .collect(Collectors.groupingBy(
                        Product::getCategory,
                        Collectors.counting()
                    ));

                // 根据偏好推荐同类别的高评分商品
                return products.stream()
                    .filter(p -> preferredCategories.containsKey(p.getCategory()))
                    .filter(p -> p.getRating() >= 4.0)
                    .sorted(Comparator.comparing(Product::getRating).reversed())
                    .limit(limit)
                    .collect(Collectors.toList());
            };

        // 3. 热门商品推荐
        public static final RecommendationStrategy TRENDING =
            (userId, products, behaviors, limit) -> {
                return products.stream()
                    .sorted(Comparator.comparing(Product::getSalesCount).reversed()
                           .thenComparing(Product::getRating, Comparator.reverseOrder()))
                    .limit(limit)
                    .collect(Collectors.toList());
            };

        // 4. 价格敏感推荐
        public static final RecommendationStrategy PRICE_SENSITIVE =
            (userId, products, behaviors, limit) -> {
                // 分析用户的价格偏好
                OptionalDouble avgPrice = behaviors.stream()
                    .filter(b -> b.getUserId().equals(userId))
                    .filter(b -> "PURCHASE".equals(b.getAction()))
                    .map(UserBehavior::getProductId)
                    .map(productId -> products.stream()
                        .filter(p -> p.getProductId().equals(productId))
                        .findFirst().orElse(null))
                    .filter(Objects::nonNull)
                    .mapToDouble(Product::getPrice)
                    .average();

                double priceThreshold = avgPrice.orElse(1000.0);

                return products.stream()
                    .filter(p -> p.getPrice() <= priceThreshold * 1.2) // 允许20%的价格浮动
                    .filter(p -> p.getRating() >= 3.5)
                    .sorted(Comparator.comparing(Product::getRating).reversed())
                    .limit(limit)
                    .collect(Collectors.toList());
            };
    }

    // 推荐引擎主类
    public static class RecommendationEngine {
        private final List<Product> products;
        private final List<UserBehavior> userBehaviors;

        public RecommendationEngine(List<Product> products, List<UserBehavior> userBehaviors) {
            this.products = products;
            this.userBehaviors = userBehaviors;
        }

        // 获取个性化推荐
        public List<Product> getPersonalizedRecommendations(String userId, int limit) {
            // 组合多种推荐策略
            RecommendationStrategy combinedStrategy =
                RecommendationStrategies.COLLABORATIVE_FILTERING
                    .combine(RecommendationStrategies.CONTENT_BASED, 0.4, 0.3)
                    .combine(RecommendationStrategies.PRICE_SENSITIVE, 0.7, 0.3);

            return combinedStrategy.recommend(userId, products, userBehaviors, limit);
        }

        // 获取热门推荐
        public List<Product> getTrendingRecommendations(int limit) {
            return RecommendationStrategies.TRENDING
                .recommend(null, products, userBehaviors, limit);
        }

        // 基于特定策略的推荐
        public List<Product> getRecommendations(String userId,
                                               RecommendationStrategy strategy,
                                               int limit) {
            return strategy.recommend(userId, products, userBehaviors, limit);
        }
    }

    // 演示方法
    public static void main(String[] args) {
        System.out.println("=== 商品推荐系统演示 ===");

        // 创建测试数据
        List<Product> products = Arrays.asList(
            new Product("P001", "iPhone 15", "手机", 6999.0, 4.8,
                       Set.of("苹果", "5G", "高端"), 1500),
            new Product("P002", "小米14", "手机", 3999.0, 4.6,
                       Set.of("小米", "5G", "性价比"), 2000),
            new Product("P003", "MacBook Pro", "笔记本", 12999.0, 4.9,
                       Set.of("苹果", "专业", "高性能"), 800),
            new Product("P004", "AirPods Pro", "耳机", 1999.0, 4.7,
                       Set.of("苹果", "降噪", "无线"), 3000),
            new Product("P005", "华为MateBook", "笔记本", 5999.0, 4.5,
                       Set.of("华为", "轻薄", "商务"), 1200)
        );

        List<UserBehavior> behaviors = Arrays.asList(
            new UserBehavior("USER001", "P001", "PURCHASE", System.currentTimeMillis()),
            new UserBehavior("USER001", "P004", "CART", System.currentTimeMillis()),
            new UserBehavior("USER001", "P003", "VIEW", System.currentTimeMillis()),
            new UserBehavior("USER002", "P001", "PURCHASE", System.currentTimeMillis()),
            new UserBehavior("USER002", "P002", "VIEW", System.currentTimeMillis())
        );

        RecommendationEngine engine = new RecommendationEngine(products, behaviors);

        // 获取个性化推荐
        System.out.println("\n🎯 USER001的个性化推荐:");
        List<Product> personalizedRecs = engine.getPersonalizedRecommendations("USER001", 3);
        personalizedRecs.forEach(System.out::println);

        // 获取热门推荐
        System.out.println("\n🔥 热门商品推荐:");
        List<Product> trendingRecs = engine.getTrendingRecommendations(3);
        trendingRecs.forEach(System.out::println);

        // 基于内容的推荐
        System.out.println("\n📚 基于内容的推荐:");
        List<Product> contentRecs = engine.getRecommendations("USER001",
            RecommendationStrategies.CONTENT_BASED, 3);
        contentRecs.forEach(System.out::println);
    }
}

🎯 示例4：金融风险评估系统

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.LocalDate;
import java.util.*;
import java.util.function.*;
import java.util.stream.Collectors;

/**
 * 金融风险评估系统 - Lambda表达式在金融业务中的应用
 */
public class FinancialRiskAssessment {

    // 客户信息
    public static class Customer {
        private String customerId;
        private String name;
        private int age;
        private String occupation;
        private BigDecimal annualIncome;
        private int creditScore;
        private List<LoanHistory> loanHistory;
        private LocalDate registrationDate;

        public Customer(String customerId, String name, int age, String occupation,
                       BigDecimal annualIncome, int creditScore, List<LoanHistory> loanHistory) {
            this.customerId = customerId;
            this.name = name;
            this.age = age;
            this.occupation = occupation;
            this.annualIncome = annualIncome;
            this.creditScore = creditScore;
            this.loanHistory = loanHistory != null ? loanHistory : new ArrayList<>();
            this.registrationDate = LocalDate.now();
        }

        // getter方法
        public String getCustomerId() { return customerId; }
        public String getName() { return name; }
        public int getAge() { return age; }
        public String getOccupation() { return occupation; }
        public BigDecimal getAnnualIncome() { return annualIncome; }
        public int getCreditScore() { return creditScore; }
        public List<LoanHistory> getLoanHistory() { return loanHistory; }
        public LocalDate getRegistrationDate() { return registrationDate; }
    }

    // 贷款历史
    public static class LoanHistory {
        private BigDecimal amount;
        private LocalDate startDate;
        private LocalDate endDate;
        private boolean defaulted;
        private int daysOverdue;

        public LoanHistory(BigDecimal amount, LocalDate startDate, LocalDate endDate,
                          boolean defaulted, int daysOverdue) {
            this.amount = amount;
            this.startDate = startDate;
            this.endDate = endDate;
            this.defaulted = defaulted;
            this.daysOverdue = daysOverdue;
        }

        public BigDecimal getAmount() { return amount; }
        public LocalDate getStartDate() { return startDate; }
        public LocalDate getEndDate() { return endDate; }
        public boolean isDefaulted() { return defaulted; }
        public int getDaysOverdue() { return daysOverdue; }
    }

    // 风险评估规则
    public static class RiskAssessmentRules {

        // 1. 信用评分风险因子
        public static final Function<Customer, BigDecimal> CREDIT_SCORE_FACTOR =
            customer -> {
                int score = customer.getCreditScore();
                if (score >= 750) return new BigDecimal("1.0");
                if (score >= 650) return new BigDecimal("0.8");
                if (score >= 550) return new BigDecimal("0.6");
                return new BigDecimal("0.3");
            };

        // 2. 收入稳定性因子
        public static final Function<Customer, BigDecimal> INCOME_STABILITY_FACTOR =
            customer -> {
                String occupation = customer.getOccupation();
                BigDecimal income = customer.getAnnualIncome();

                BigDecimal occupationFactor = switch (occupation.toLowerCase()) {
                    case "公务员", "教师", "医生" -> new BigDecimal("1.0");
                    case "工程师", "会计师", "律师" -> new BigDecimal("0.9");
                    case "销售", "自由职业" -> new BigDecimal("0.7");
                    default -> new BigDecimal("0.8");
                };

                BigDecimal incomeFactor = income.compareTo(new BigDecimal("100000")) >= 0 ?
                    new BigDecimal("1.0") : new BigDecimal("0.8");

                return occupationFactor.multiply(incomeFactor);
            };

        // 3. 历史还款记录因子
        public static final Function<Customer, BigDecimal> PAYMENT_HISTORY_FACTOR =
            customer -> {
                List<LoanHistory> history = customer.getLoanHistory();
                if (history.isEmpty()) {
                    return new BigDecimal("0.7"); // 无历史记录，中等风险
                }

                long defaultCount = history.stream()
                    .mapToLong(loan -> loan.isDefaulted() ? 1 : 0)
                    .sum();

                double avgOverdueDays = history.stream()
                    .mapToInt(LoanHistory::getDaysOverdue)
                    .average()
                    .orElse(0.0);

                if (defaultCount == 0 && avgOverdueDays <= 5) {
                    return new BigDecimal("1.0");
                } else if (defaultCount <= 1 && avgOverdueDays <= 15) {
                    return new BigDecimal("0.8");
                } else if (defaultCount <= 2 && avgOverdueDays <= 30) {
                    return new BigDecimal("0.6");
                } else {
                    return new BigDecimal("0.3");
                }
            };

        // 4. 年龄风险因子
        public static final Function<Customer, BigDecimal> AGE_RISK_FACTOR =
            customer -> {
                int age = customer.getAge();
                if (age >= 25 && age <= 55) return new BigDecimal("1.0");
                if (age >= 18 && age <= 65) return new BigDecimal("0.9");
                return new BigDecimal("0.7");
            };
    }

    // 风险评估引擎
    public static class RiskAssessmentEngine {

        // 综合风险评估
        public static BigDecimal assessRisk(Customer customer) {
            // 计算各项风险因子
            BigDecimal creditFactor = RiskAssessmentRules.CREDIT_SCORE_FACTOR.apply(customer);
            BigDecimal incomeFactor = RiskAssessmentRules.INCOME_STABILITY_FACTOR.apply(customer);
            BigDecimal paymentFactor = RiskAssessmentRules.PAYMENT_HISTORY_FACTOR.apply(customer);
            BigDecimal ageFactor = RiskAssessmentRules.AGE_RISK_FACTOR.apply(customer);

            // 权重计算综合风险评分
            return creditFactor.multiply(new BigDecimal("0.30"))
                .add(incomeFactor.multiply(new BigDecimal("0.25")))
                .add(paymentFactor.multiply(new BigDecimal("0.25")))
                .add(ageFactor.multiply(new BigDecimal("0.20")))
                .multiply(new BigDecimal("100"))
                .setScale(2, RoundingMode.HALF_UP);
        }

        // 批量风险评估
        public static Map<String, BigDecimal> batchAssessment(List<Customer> customers) {
            return customers.parallelStream()
                .collect(Collectors.toMap(
                    Customer::getCustomerId,
                    RiskAssessmentEngine::assessRisk
                ));
        }

        // 风险等级分类
        public static Map<String, List<Customer>> classifyByRiskLevel(List<Customer> customers) {
            return customers.stream()
                .collect(Collectors.groupingBy(customer -> {
                    BigDecimal riskScore = assessRisk(customer);
                    if (riskScore.compareTo(new BigDecimal("80")) >= 0) return "低风险";
                    if (riskScore.compareTo(new BigDecimal("60")) >= 0) return "中风险";
                    return "高风险";
                }));
        }
    }

    // 演示方法
    public static void main(String[] args) {
        System.out.println("=== 金融风险评估系统演示 ===");

        // 创建测试客户数据
        List<Customer> customers = Arrays.asList(
            new Customer("CUST001", "张三", 35, "工程师",
                new BigDecimal("150000"), 720, Arrays.asList(
                    new LoanHistory(new BigDecimal("50000"),
                        LocalDate.of(2020, 1, 1), LocalDate.of(2023, 1, 1), false, 2)
                )),
            new Customer("CUST002", "李四", 28, "销售",
                new BigDecimal("80000"), 650, new ArrayList<>()),
            new Customer("CUST003", "王五", 45, "公务员",
                new BigDecimal("120000"), 780, Arrays.asList(
                    new LoanHistory(new BigDecimal("100000"),
                        LocalDate.of(2019, 6, 1), LocalDate.of(2024, 6, 1), false, 0)
                ))
        );

        // 执行批量风险评估
        Map<String, BigDecimal> riskScores = RiskAssessmentEngine.batchAssessment(customers);

        System.out.println("\n📊 风险评估结果:");
        riskScores.forEach((customerId, score) ->
            System.out.println(customerId + ": " + score + "分"));

        // 风险等级分类
        System.out.println("\n📈 风险等级分布:");
        Map<String, List<Customer>> riskClassification = RiskAssessmentEngine.classifyByRiskLevel(customers);
        riskClassification.forEach((level, customerList) ->
            System.out.println(level + ": " + customerList.size() + "位客户"));
    }
}

💼 业务价值体现

• 🎯 精确计算：使用BigDecimal确保金融计算的精度
• 📊 多因子模型：通过函数组合实现复杂的风险评估模型
• ⚡ 批量处理：利用并行流提升大批量数据处理性能
• 🔧 规则引擎：函数式的业务规则定义和执行

🚀 技术优势

• 类型安全：编译时检查，避免计算错误
• 可测试性：每个风险因子都可以独立测试
• 可扩展性：新增风险因子只需添加新的函数
• 性能优化：并行计算提升处理效率

💼 业务价值体现

• 📊 多维分析：支持按时间、地区、产品等多个维度进行数据分析
• 📈 趋势分析：通过时间序列分析发现业务趋势
• 🎯 客户洞察：深入分析客户行为和价值分布
• 📋 动态报表：根据不同需求生成定制化报表

🚀 技术优势

• 声明式编程：用更少的代码表达复杂的数据处理逻辑
• 链式操作：数据处理流程清晰易懂
• 并行处理：自动利用多核CPU提升处理性能
• 内存效率：流式处理避免创建大量中间集合

🔗 Lambda表达式核心原理

• ✅ 底层实现机制：invokedynamic指令和方法句柄的优化
• ✅ 函数式接口设计：单一抽象方法 + 默认方法组合
• ✅ 编译器优化：字节码级别的性能优化
• ✅ 类型推断：编译器自动推断Lambda表达式类型

💼 电商业务场景应用

• ✅ 订单处理流水线：函数组合实现复杂业务流程
• ✅ 业务规则验证：组合验证器的灵活应用
• ✅ 推荐系统：策略模式的函数式实现
• ✅ 优惠计算：多策略组合的动态计算

🏦 金融系统实践

• ✅ 风险评估模型：多因子模型的函数式实现
• ✅ 精确计算：BigDecimal确保金融计算精度
• ✅ 批量处理：并行流提升处理性能
• ✅ 规则引擎：函数式业务规则定义

📊 数据分析应用

• ✅ 多维数据分析：Stream API的强大数据处理能力
• ✅ 统计计算：声明式的统计指标计算
• ✅ 报表生成：动态报表的函数式实现
• ✅ 性能优化：并行处理和内存优化

🎯 自我检测清单

• 理解Lambda表达式的底层实现原理
• 掌握函数式接口的设计和使用
• 能够设计电商订单处理流水线
• 实现商品推荐系统的策略模式
• 构建金融风险评估模型
• 进行复杂的数据分析和统计

📖 下篇预告

在下篇中，我们将深入探讨：

• 🌐 微服务架构：事件驱动架构与消息处理
• ⚡ 性能优化：Lambda表达式的性能调优技巧
• 🔧 高级技巧：函数组合、柯里化、Monad模式
• 📝 实战项目：完整的函数式业务规则引擎