调整TXT文件列顺序：解决行间缺失列导致的列序混乱

看起来你已经走对了第一步——收集了所有新增字段，但还需要把每行内容按「首行已存在字段+新增字段」的顺序重新排列。我来帮你梳理完整流程，并且完善你的代码：

核心思路 #

1. 锁定首行的基准字段：先读取首行，解析出所有键并保留原始顺序（这是我们的列序标准），同时存入集合方便快速判断；
2. 拆分每行的键值对：把每行按|分割成单个键值对，再拆成键和值，方便后续分类处理；
3. 重组行内容：
   • 先按首行的顺序，依次拼接存在的键值对，保证原有列序不乱；
   • 再把首行没有的键值对，按它们在原行的出现顺序拼到行尾；
4. 输出调整后的内容：写入新文件避免覆盖原文件，确保数据安全。

完整代码实现 #

import java.io.*;
import java.util.*;
import java.util.AbstractMap.SimpleEntry;

public class TextColumnAdjuster {
    // 存储首行的键，保留原始顺序作为基准
    private static List<String> headerKeys = new ArrayList<>();
    // 存储首行键的集合，用于快速判断键是否存在
    private static Set<String> headerKeySet = new HashSet<>();

    public static void main(String[] args) {
        ladeDatei("your-input-file.txt"); // 替换为你的实际文件名
    }

    private static void ladeDatei(String datName) {
        File file = new File(datName);
        if (!file.canRead() || !file.isFile()) {
            System.err.println("无法读取目标文件或文件不存在");
            System.exit(0);
        }

        BufferedReader in = null;
        BufferedWriter out = null;
        boolean isFirstLine = true;

        try {
            in = new BufferedReader(new FileReader(datName));
            // 生成新文件存储调整后内容，避免覆盖原文件
            out = new BufferedWriter(new FileWriter("adjusted-" + datName));
            String row;

            while ((row = in.readLine()) != null) {
                if (row.trim().isEmpty()) {
                    out.write(row);
                    out.newLine();
                    continue;
                }

                // 处理首行，提取基准键的顺序和集合
                if (isFirstLine) {
                    parseHeader(row);
                    isFirstLine = false;
                    out.write(row);
                    out.newLine();
                    continue;
                }

                // 处理后续行，重组内容
                String adjustedRow = adjustRow(row);
                out.write(adjustedRow);
                out.newLine();
            }

            System.out.println("文件处理完成，已生成调整后的文件：adjusted-" + datName);

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (in != null) in.close();
                if (out != null) out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    // 解析首行，获取基准键的顺序和集合
    private static void parseHeader(String headerRow) {
        String[] keyValuePairs = headerRow.split("\\|");
        for (String pair : keyValuePairs) {
            if (pair.contains("=")) {
                String key = pair.split("=")[0].trim();
                headerKeys.add(key);
                headerKeySet.add(key);
            }
        }
    }

    // 调整单行内容：先拼接首行存在的键，再拼接新增键
    private static String adjustRow(String row) {
        StringBuilder sb = new StringBuilder();
        // 先按首行顺序拼接已存在的键值对
        Map<String, List<String>> keyValueMap = new HashMap<>();
        String[] originalPairs = row.split("\\|");
        
        // 先把所有键值对存入Map，处理重复键的情况
        for (String pair : originalPairs) {
            if (pair.contains("=")) {
                String[] parts = pair.split("=", 2); // 限制拆分次数，避免值中包含=的情况
                String key = parts[0].trim();
                String value = parts[1].trim();
                keyValueMap.computeIfAbsent(key, k -> new ArrayList<>()).add(value);
            }
        }

        // 拼接首行已存在的键值对
        for (String key : headerKeys) {
            if (keyValueMap.containsKey(key)) {
                for (String value : keyValueMap.get(key)) {
                    if (sb.length() > 0) sb.append("|");
                    sb.append(key).append("=").append(value);
                }
                keyValueMap.remove(key); // 避免重复处理
            }
        }

        // 按原顺序拼接首行没有的键值对
        Set<String> processedKeys = new HashSet<>(headerKeys);
        for (String pair : originalPairs) {
            if (pair.contains("=")) {
                String[] parts = pair.split("=", 2);
                String key = parts[0].trim();
                String value = parts[1].trim();
                if (!processedKeys.contains(key)) {
                    if (sb.length() > 0) sb.append("|");
                    sb.append(key).append("=").append(value);
                    processedKeys.add(key);
                }
            }
        }

        return sb.toString();
    }
}

关键细节说明 #

• 处理重复键：你的示例中存在重复键（如865=5和865=7），代码用List存储同一个键的多个值，确保数据不丢失；
• 保留原始顺序：新增字段会严格按照它们在原行的出现顺序放到行尾，不会打乱原有逻辑；
• 容错设计：跳过空行，处理值中包含=的特殊情况，避免拆分错误；
• 安全写入：生成新文件存储结果，不会覆盖原文件，降低数据风险。

你只需要替换代码中的文件名，运行后就能得到列序统一的目标文件了。

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