如何用Java8 Stream简化多If-else分支并实现多条件过滤？

1. 如何减少If-else链式结构？ #

采用责任链模式封装每个分支逻辑，将判断条件与处理逻辑分离，按优先级顺序执行处理器，找到第一个匹配条件的处理器后返回结果即可。

核心步骤：

• 定义统一的处理器接口，包含判断是否可处理的方法和具体处理方法
• 为每个原If-else分支实现独立的处理器类
• 将处理器按优先级放入列表，遍历列表找到第一个满足条件的处理器并执行

2. 如何在Stream中过滤集合范围外的数据？ #

你遇到的IDE错误是因为Predicate类型不匹配：isMoreThanTwoEvents是针对List<Event>的断言，但stream().filter()需要的是单个Event的Predicate<? super Event>。

集合级别的条件（如列表大小、外部参数results）应作为外层判断逻辑，而非嵌入单个元素的过滤断言中。正确的做法是先验证集合/外部条件，再对集合内元素执行Stream过滤：

// 正确示例：先判断集合级条件，再处理元素过滤
if (eventList.size() > 1 && results.getAcknowledgeUid().isEmpty()) {
    event = eventList.stream()
        .filter(isOriginalEvent.and(isSOPEvent).and(isSOPSpecialEvent))
        .findFirst().orElse(null);
}

若需结合集合上下文与元素条件，可将集合作为参数传入处理器，在处理器内统一处理层级判断。

3. 更优或更优雅的解决方案？ #

结合责任链模式与Predicate复用，给出完整优化示例：

第一步：定义处理器接口 #

interface EventProcessor {
    boolean canProcess(List<Event> eventList, Results results);
    Event process(List<Event> eventList, Results results);
}

第二步：实现各分支处理器 #

// SOP特殊事件处理器
class SOPSpecialEventProcessor implements EventProcessor {
    @Override
    public boolean canProcess(List<Event> eventList, Results results) {
        return eventList.size() > 1 && results.getAcknowledgeUid().isEmpty();
    }

    @Override
    public Event process(List<Event> eventList, Results results) {
        return eventList.stream()
            .filter(isOriginalEvent.and(isSOPEvent).and(isSOPSpecialEvent))
            .findFirst().orElse(null);
    }
}

// SOP确认事件处理器
class SOPAcknowledgeEventProcessor implements EventProcessor {
    @Override
    public boolean canProcess(List<Event> eventList, Results results) {
        return eventList.size() > 1 && !results.getAcknowledgeUid().isEmpty()
            && "SOP".equalsIgnoreCase(eventList.get(0).getEventType());
    }

    @Override
    public Event process(List<Event> eventList, Results results) {
        return eventList.stream()
            .filter(isAcknowledgeEvent)
            .findFirst().orElse(null);
    }
}

// 非SOP确认事件处理器
class NonSOPAcknowledgeEventProcessor implements EventProcessor {
    private final EventRepository repository;

    public NonSOPAcknowledgeEventProcessor(EventRepository repository) {
        this.repository = repository;
    }

    @Override
    public boolean canProcess(List<Event> eventList, Results results) {
        return eventList.size() > 1 && !results.getAcknowledgeUid().isEmpty()
            && !"SOP".equalsIgnoreCase(eventList.get(0).getEventType());
    }

    @Override
    public Event process(List<Event> eventList, Results results) {
        List<Event> acknowledgeList = repository.findEventByUid(results.getAcknowledgeUid());
        return acknowledgeList.stream()
            .filter(isAcknowledgeEvent)
            .findFirst().orElse(null);
    }
}

// 单个事件处理器
class SingleEventProcessor implements EventProcessor {
    @Override
    public boolean canProcess(List<Event> eventList, Results results) {
        return eventList.size() == 1;
    }

    @Override
    public Event process(List<Event> eventList, Results results) {
        return eventList.stream()
            .filter(isOriginalEvent)
            .findFirst().orElse(null);
    }
}

第三步：执行处理器链 #

// 按优先级初始化处理器列表
List<EventProcessor> processors = Arrays.asList(
    new SOPSpecialEventProcessor(),
    new SOPAcknowledgeEventProcessor(),
    new NonSOPAcknowledgeEventProcessor(repository),
    new SingleEventProcessor()
);

// 遍历找到第一个可处理的处理器并执行
Event event = processors.stream()
    .filter(p -> p.canProcess(eventList, results))
    .findFirst()
    .map(p -> p.process(eventList, results))
    .orElse(null);

该方案优势：

• 彻底消除If-else链，代码结构清晰
• 每个处理器职责单一，便于单元测试和后续维护
• 新增条件时只需添加新处理器类，无需修改原有逻辑

内容的提问来源于stack exchange，提问作者turing23