如何高效清理依赖已删除Class B的无效Class A对象

我们有1000个带唯一ID的Class A对象列表，Class A的JSON结构如下：

A : {
  "id" : "id1",
  "usedBy": {
    "type": "代表Class B的枚举值",
    "id": "id2"
  }
}

Class B对象可被外部请求独立删除，导致依赖它的Class A对象失效。系统中存在大量Class B对象，但并非所有都与Class A关联，需要定期检查并删除所有依赖已不存在的Class B的无效Class A对象。

当前实现采用多分支嵌套循环，不符合代码质量规范（单方法最多允许3个if/else/for），现有代码片段如下：

public void validateForAutoCleanUp(OperationContext context, Page<ClassA> page) {

    List<ClassA> invalidsToDelete = new ArrayList<>();
    List<ClassA> existing = page.getContent().stream().toList();
        
    List<String> usedByIds = page.getContent().stream().map(ClassA::getUsedBy).map(UsedBy::getId).toList();
    List<ClassB> bList = service.getAllofTypeB(context, pageNumber, pageSize, null, null).block();

    if (bList != null) {
        List<String> invalidUsedByIds = usedByIds.stream().filter(id -> ! bList.stream().map(ClassB::getId).toList().contains(id)).toList();
        if (!invalidUsedByIds.isEmpty()) {
            for (ClassA a : existing) {
                for (String invalidId : invalidUsedByIds) {
                    if (a.getUsedBy().getId().equals(invalidId)) {
                        invalidsToDelete.add(a);
                        break;
                    }
                }
            }
            if (!invalidsToDelete.isEmpty())
                invalidsToDelete.forEach(i -> service.deleteById(context, i.getId()).block());
        } else {
            page.getContent().forEach(a -> service.deleteById(context, a.getId()).block());
        }
    }
}

核心优化点 #

• 用HashSet存储有效Class B的ID，将存在性检查的时间复杂度从O(n)降到O(1)
• 用流式操作串联筛选逻辑，替代嵌套循环与多层分支
• 简化空值处理，减少冗余集合创建
• 严格控制单方法内的条件分支与循环数量

优化后的代码 #

public void validateForAutoCleanUp(OperationContext context, Page<ClassA> page) {
    List<ClassA> classAList = page.getContent();
    if (classAList.isEmpty()) {
        return;
    }

    // 获取所有有效Class B的ID，存入HashSet提升查询效率
    Set<String> validBIds = Optional.ofNullable(service.getAllofTypeB(context, pageNumber, pageSize, null, null).block())
            .orElse(Collections.emptyList())
            .stream()
            .map(ClassB::getId)
            .collect(Collectors.toSet());

    // 直接筛选出依赖无效Class B的Class A对象
    List<ClassA> invalidClassAs = classAList.stream()
            .filter(a -> !validBIds.contains(a.getUsedBy().getId()))
            .toList();

    // 批量删除无效对象
    if (!invalidClassAs.isEmpty()) {
        invalidClassAs.forEach(a -> service.deleteById(context, a.getId()).block());
    }
}

优化说明 #

1. 性能优化：通过HashSet替代多次流遍历+contains操作，大幅降低查询耗时，避免嵌套循环的性能损耗
2. 代码合规：单方法内仅2个条件分支、0个嵌套循环，完全符合代码质量规范要求
3. 可读性提升：逻辑拆分清晰，每一步只完成单一职责，无需多层嵌套理解
4. 空值安全：用Optional处理Class B列表为空的场景，避免空指针异常，同时简化分支判断

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