如何通过Foreach循环合并Java Process对象列表以生成含完整数据的目标列表

看起来你需要把同ID下分散的步骤（带name无status）和状态（带status无name）对应起来，生成每个步骤都带有正确状态的完整对象列表对吧？我刚好有个贴合你场景的实现方案，用你要求的foreach循环就能搞定。

实现思路 #

你的数据结构很清晰：同ID下总是先出现一批带name的步骤对象，然后出现一个对应这些步骤的status对象。所以我们可以：

1. 先把所有Process按ID分组，这样能单独处理每个ID下的对象集合
2. 正序遍历每个ID的对象列表：
   • 遇到带name但status为空的对象，先暂存起来
   • 遇到带status但name为空的对象时，把暂存的所有步骤对象和这个status合并，生成完整对象加入结果列表

完整代码示例 #

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

public class ProcessMerger {
    public static void main(String[] args) {
        // 初始化你的processList，这里用你提供的代码
        List<Process> processList = new ArrayList<>();
        Process process1 = new Process();
        process1.setId("1111");
        process1.setName("Step one under first status");
        process1.setDate(new Date());
        process1.setStatus("");
        Process process2 = new Process();
        process2.setId("1111");
        process2.setName("Step two under first status");
        process2.setDate(new Date());
        process2.setStatus("");
        Process process3 = new Process();
        process3.setId("1111");
        process3.setName("");
        process3.setDate(new Date());
        process3.setStatus("Status One");
        Process process4 = new Process();
        process4.setId("1111");
        process4.setName("Step one under second status");
        process4.setDate(new Date());
        process4.setStatus("");
        Process process5 = new Process();
        process5.setId("1111");
        process5.setName("");
        process5.setDate(new Date());
        process5.setStatus("Status two");
        Process process6 = new Process();
        process6.setId("2222");
        process6.setName("Step one under first status");
        process6.setDate(new Date());
        process6.setStatus("");
        Process process7 = new Process();
        process7.setId("2222");
        process7.setName("Step two under first status");
        process7.setDate(new Date());
        process7.setStatus("");
        Process process8 = new Process();
        process8.setId("2222");
        process8.setName("");
        process8.setDate(new Date());
        process8.setStatus("Status One");
        processList.add(process1);
        processList.add(process2);
        processList.add(process3);
        processList.add(process4);
        processList.add(process5);
        processList.add(process6);
        processList.add(process7);
        processList.add(process8);

        // 开始合并操作
        List<Process> mergedProcessList = new ArrayList<>();
        // 1. 按ID分组
        Map<String, List<Process>> idToProcessesMap = new HashMap<>();
        for (Process p : processList) {
            idToProcessesMap.computeIfAbsent(p.getId(), key -> new ArrayList<>()).add(p);
        }

        // 2. 处理每个ID下的对象
        for (Map.Entry<String, List<Process>> entry : idToProcessesMap.entrySet()) {
            List<Process> currentIdProcesses = entry.getValue();
            List<Process> tempStepList = new ArrayList<>();

            for (Process p : currentIdProcesses) {
                // 判断是否是带name的步骤对象（status为空）
                boolean isStep = p.getName() != null && !p.getName().trim().isEmpty()
                        && (p.getStatus() == null || p.getStatus().trim().isEmpty());
                // 判断是否是带status的状态对象（name为空）
                boolean isStatus = p.getStatus() != null && !p.getStatus().trim().isEmpty()
                        && (p.getName() == null || p.getName().trim().isEmpty());

                if (isStep) {
                    // 暂存步骤对象
                    tempStepList.add(p);
                } else if (isStatus) {
                    // 合并暂存的步骤和当前状态
                    String currentStatus = p.getStatus();
                    for (Process step : tempStepList) {
                        Process mergedProcess = new Process();
                        mergedProcess.setId(step.getId());
                        mergedProcess.setName(step.getName());
                        mergedProcess.setDate(step.getDate()); // 用步骤的日期，如需用状态日期可改成p.getDate()
                        mergedProcess.setStatus(currentStatus);
                        mergedProcessList.add(mergedProcess);
                    }
                    // 清空暂存列表，准备接收下一批步骤
                    tempStepList.clear();
                }
            }

            // 处理遍历结束后剩余的未匹配状态的步骤（如果有的话）
            // 比如可以给默认状态，或者忽略，根据你的业务需求调整
            // for (Process step : tempStepList) {
            //     Process mergedProcess = new Process();
            //     mergedProcess.setId(step.getId());
            //     mergedProcess.setName(step.getName());
            //     mergedProcess.setDate(step.getDate());
            //     mergedProcess.setStatus("Default Status");
            //     mergedProcessList.add(mergedProcess);
            // }
        }

        // 打印结果验证
        for (Process p : mergedProcessList) {
            System.out.printf("id = \"%s\", name = \"%s\", date = %s, status = \"%s\"\n",
                    p.getId(), p.getName(), p.getDate(), p.getStatus());
        }
    }

    // 你的Process类（这里为了完整包含进来）
    static class Process {
        private String id;
        private String name;
        private Date date;
        private String status;

        // getter、setter方法
        public String getId() { return id; }
        public void setId(String id) { this.id = id; }
        public String getName() { return name; }
        public void setName(String name) { this.name = name; }
        public Date getDate() { return date; }
        public void setDate(Date date) { this.date = date; }
        public String getStatus() { return status; }
        public void setStatus(String status) { this.status = status; }
    }
}

关键说明 #

• 空值判断：我用了!= null && !trim().isEmpty()来避免空格导致的误判，比单纯判断isEmpty()更严谨
• 日期选择：合并时默认用步骤对象的日期，如果你需要用状态对象的日期，只需要把mergedProcess.setDate(step.getDate())改成mergedProcess.setDate(p.getDate())
• 剩余步骤处理：如果你的数据里存在最后一批步骤没有对应状态的情况，可以取消注释最后那段代码，给这些步骤设置默认状态或者做其他处理

运行这段代码后，输出的结果就完全符合你想要的目标列表结构啦！

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