如何避免Java嵌套循环 将双层for循环改写为单层循环赋值

问题根因 #

之前使用HashMap失效的核心原因是key选取错误：单独使用AssociateId作为key时，同一AssociateId会对应多条Plan记录，后写入的value会覆盖之前的value，无法匹配到正确结果。

实现思路 #

利用组合唯一键构建HashMap，全程仅需一次列表预处理+一次CoverageDetail列表遍历，无嵌套循环，逻辑和原嵌套实现完全对齐：

• 选取AssociateId + "_" + productCode作为HashMap的key，该组合键在Plan列表中唯一，不会出现值覆盖问题，value存储对应Plan对象
• 预处理plans列表完成HashMap构建后，单层遍历所有CoverageDetail对象，用自身AssociateId + "_" + coverageId作为key直接从HashMap中取出匹配的Plan对象
• 从匹配到的Plan中取出classCode、planCode赋值给当前CoverageDetail即可

注：原嵌套循环逻辑中，匹配到productCode相等的Plan时会执行break终止内层循环，此时CoverageDetail的classCode、planCode均来自这一条匹配的Plan，和组合键匹配逻辑完全一致，不存在结果偏差。

可运行示例代码 #

import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class CoverageConvertUtil {
    public void fillCoverageInfo(EmployeeCoverage employeeCoverage, List<Plan> plans) {
        List<CoverageDetail> coverageDetailList = employeeCoverage.getCoverageDetailList();
        if (coverageDetailList == null || coverageDetailList.isEmpty() || plans == null || plans.isEmpty()) {
            return;
        }

        // 预处理构建组合键Map
        Map<String, Plan> planMatchMap = new HashMap<>();
        for (Plan plan : plans) {
            String matchKey = plan.getAssociateId() + "_" + plan.getProductCode();
            planMatchMap.put(matchKey, plan);
        }

        // 单层遍历CoverageDetail完成赋值
        for (CoverageDetail coverageDetail : coverageDetailList) {
            String matchKey = coverageDetail.getAssociateId() + "_" + coverageDetail.getCoverageId();
            Plan matchedPlan = planMatchMap.get(matchKey);
            if (matchedPlan != null) {
                coverageDetail.setClassCode(matchedPlan.getClassCode());
                coverageDetail.setPlanCode(matchedPlan.getPlanCode());
            }
        }
    }

    // 对齐需求字段的类定义参考
    class CoverageDetail {
        private String AssociateId;
        private String coverageId;
        private String classCode;
        private String planCode;

        public String getAssociateId() {return AssociateId;}
        public void setAssociateId(String associateId) {AssociateId = associateId;}
        public String getCoverageId() {return coverageId;}
        public void setCoverageId(String coverageId) {this.coverageId = coverageId;}
        public void setClassCode(String classCode) {this.classCode = classCode;}
        public void setPlanCode(String planCode) {this.planCode = planCode;}
    }

    class Plan {
        private String planCode;
        private String AssociateId;
        private String classCode;
        private String productCode;

        public String getPlanCode() {return planCode;}
        public String getAssociateId() {return AssociateId;}
        public String getClassCode() {return classCode;}
        public String getProductCode() {return productCode;}
    }

    class EmployeeCoverage {
        public List<CoverageDetail> getCoverageDetailList() {
            // 替换为实际业务获取逻辑
            return null;
        }
    }
}

逻辑校验 #

针对给出的场景：coverageDetailList中所有对象AssociateId相同、仅coverageId不同，该实现可以正确给每个CoverageDetail匹配到对应Plan的classCode和planCode，和原嵌套循环执行结果完全一致，不会出现key覆盖问题。如果实际代码中getter/setter命名存在拼写偏差（如原代码片段中getAssocaiteId的拼写笔误），直接替换为实际方法名即可。

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