Java 中如何高效校验列顺序不同的 CSV 文件数据一致性

a,b,c
1,2,3
4,5,6

a,c,b
1,3,2
4,6,5

package comparecsv;

import java.util.Objects;

public class Pair <T, U> {

    private final T t;
    private final U u;

    public Pair (T aT, U aU) {
        this.t = aT;
        this.u = aU;
    }

    // 获取第一个元素
    public T getFirst() {
        return t;
    }

    // 获取第二个元素
    public U getSecond() {
        return u;
    }

    @Override
    public int hashCode() {
        int hash = 3;
        hash = 59 * hash + Objects.hashCode(this.t);
        hash = 59 * hash + Objects.hashCode(this.u);
        return hash;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {  return true;   }
        if (obj == null) {  return false;  }
        if (getClass() != obj.getClass()) {  return false;   }
        final Pair<?, ?> other = (Pair<?, ?>) obj;
        if (!Objects.equals(this.t, other.t)) {
            return false;
        }
        return Objects.equals(this.u, other.u);
    } // end equals

    @Override
    public String toString() {
        return "(" + t + ", " + u + ")";
    }
} // end class Pair

package comparecsv;

import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public final class CompareCSV {

    private final Set<Set<Pair<String, String>>> theSet;
    private final String[] columnHeaders; // 存储列头

    // 私有构造器，用于初始化列头和存储数据的Set
    private CompareCSV (String columnHeadingsLine, String headerSplitRegex) {
        this.columnHeaders = columnHeadingsLine.split(headerSplitRegex);
        this.theSet = new HashSet<>();
    }

    // 将一行数据字符串转换为 Set<Pair<String, String>>
    private Set<Pair<String, String>> createLine (String dataLine, String columnSplitRegex) {
        String[] columnValues = dataLine.split(columnSplitRegex);
        Set<Pair<String, String>> lineSet = new HashSet<>();
        // 遍历列值，将其与对应的列头配对
        for (int i = 0; i < columnValues.length; i++) {
            // 确保列值数量不超过列头数量，避免索引越界
            if (i < columnHeaders.length) {
                lineSet.add(new Pair<>(columnValues[i], columnHeaders[i]));
            } else {
                // 可选：处理数据行比头行多列的情况，这里选择忽略或抛出异常
                System.err.println("Warning: Data line has more columns than header: " + dataLine);
                break; // 或者 continue
            }
        }
        return lineSet;
    }

    // 获取解析后的数据集合
    public Set<Set<Pair<String, String>>> getSet () {
        return theSet;
    }

    // 获取列头（返回副本以防止外部修改）
    public String[] getColumnHeaders ()  {
        return Arrays.copyOf(columnHeaders, columnHeaders.length);
    }

    /**
     * 静态工厂方法，从 List<String> 数据创建 CompareCSV 实例。
     * @param theData 包含 CSV 数据的字符串列表，第一行为列头。
     * @param headerSplitRegex 用于分割列头的正则表达式。
     * @param columnSplitRegex 用于分割数据行的正则表达式。
     * @return 包含解析后 CSV 数据的 CompareCSV 实例。
     */
    public static CompareCSV createFromData (List<String> theData,
                                             String headerSplitRegex, String columnSplitRegex) {
        if (theData == null || theData.isEmpty()) {
            throw new IllegalArgumentException("CSV data cannot be null or empty.");
        }
        // 第一行作为列头
        CompareCSV result = new CompareCSV(theData.get(0), headerSplitRegex);
        // 从第二行开始处理数据行
        for (int i = 1; i < theData.size(); ++i) {
            result.theSet.add(result.createLine(theData.get(i), columnSplitRegex));
        }
        return result;
    }

    // 主方法，用于测试
    public static void main(String[] args) {
        // 示例源数据
        String[] sourceDataArray = {
            "a,b,c,d,e",
            "6,7,8,9,10",
            "1,2,3,4,5",
            "11,12,13,14,15",
            "16,17,18,19,20"
        };
        // 示例目标数据，列序不同，行序也可能不同
        String[] targetDataArray = {
            "c,b,e,d,a", // 列序不同
            "3,2,5,4,1",
            "8,7,10,9,6",
            "13,12,15,14,11",
            "18,17,20,19,16"
        };

        List<String> sourceList = Arrays.asList(sourceDataArray);
        List<String> targetList = Arrays.asList(targetDataArray);

        // 创建 CompareCSV 实例
        CompareCSV sourceCSV = createFromData(sourceList, ",", ",");
        CompareCSV targetCSV = createFromData(targetList, ",", ",");

        // 进行比较
        boolean sourceContainsTarget = sourceCSV.getSet().containsAll(targetCSV.getSet());
        boolean targetContainsSource = targetCSV.getSet().containsAll(sourceCSV.getSet());
        boolean areEqual = sourceCSV.getSet().equals(targetCSV.getSet()); // 检查两个Set是否完全相等

        System.out.println("源文件是否包含目标文件所有数据? " + sourceContainsTarget);
        System.out.println("目标文件是否包含源文件所有数据? " + targetContainsSource);
        System.out.println("两个文件数据是否完全相等? " + areEqual);

        // 进一步测试，例如一个文件比另一个文件多一行
        String[] sourceDataArray2 = {
            "a,b,c",
            "1,2,3",
            "4,5,6"
        };
        String[] targetDataArray2 = {
            "c,b,a",
            "3,2,1",
            "6,5,4",
            "7,8,9" // 目标文件多一行
        };
        List<String> sourceList2 = Arrays.asList(sourceDataArray2);
        List<String> targetList2 = Arrays.asList(targetDataArray2);

        CompareCSV sourceCSV2 = createFromData(sourceList2, ",", ",");
        CompareCSV targetCSV2 = createFromData(targetList2, ",", ",");

        System.out.println("\n--- 额外测试：文件数据量不一致 ---");
        System.out.println("源文件2是否包含目标文件2所有数据? " + sourceCSV2.getSet().containsAll(targetCSV2.getSet())); // 预期：false
        System.out.println("目标文件2是否包含源文件2所有数据? " + targetCSV2.getSet().containsAll(sourceCSV2.getSet())); // 预期：true
        System.out.println("两个文件2数据是否完全相等? " + targetCSV2.getSet().equals(sourceCSV2.getSet())); // 预期：false
    }
} // end class CompareCSV