java - Java 如何合并包含相同值的多个数组

Question

我正在努力通过查看它们的共享值来找到合并数组(或创建新数组)的最佳方法。

List<String[]> dictionary = new ArrayList<String[]>();

这是我的“字典”，其中包含 2 个单词的数组，例如它包含数组:

["A","B"]
["B","C"]
["D","E"]
["F","C"]
["G","H"]
["T","D"]

我需要按它们共享的值合并它们，因此例如完成的“字典”(或全新的列表)将如下所示:

["A","B","C","F"];
["D","E","T"];
["G","H"];

此外，不必删除旧数组，它们可以保留在“字典”中，但我需要合并的数组，但我很难弄清楚。

数组无论如何都不需要排序。

这是我目前所拥有的，但它不起作用

    public static void SynonymsMerge(List<String[]> dictionary){
    ArrayList<ArrayList<String>> newDictionary = new ArrayList<ArrayList<String>>();
    for(int i=0;i < dictionary.size(); i++){
        ArrayList<String> synonyms = new ArrayList<String>();
        for(int j=0; j < dictionary.get(i).length; j++){
            synonyms.add(dictionary.get(i)[j]);
        }
        newDictionary.add(synonyms);
    }
    for(int i=0;i< newDictionary.size();i++){
        for(int j=0; j < newDictionary.size();j++){
            for (int k=0; k < newDictionary.get(j).size() ;k++) {
                    if (newDictionary.get(i).equals(newDictionary.get(j)))
                        continue;
                    if (newDictionary.get(i).contains(newDictionary.get(j).get(k)))
                        newDictionary.get(i).addAll(newDictionary.get(j));

Answer 1

首先，这是代码。我将输入类型从 List<String[]> 更改为至 List<List<String>>因为混合列表和数组并没有多大意义。这也适用于输出类型。

代码

public static List<List<String>> merge(List<List<String>> dictionary) {
        List<List<String>> newDictionary = new ArrayList<>();

        for (List<String> stringPair : dictionary) {

            List<Integer> matchIndices = new ArrayList<>();
            for (int i = 0; i < newDictionary.size(); i++) {
                List<String> newStrings = newDictionary.get(i);

                for (String str : stringPair) {
                    if (newStrings.contains(str)) {
                        matchIndices.add(i);
                    }
                }
            }
            if (matchIndices.size() == 0) {
                newDictionary.addAll(new ArrayList<List<String>>(Collections.singleton(new ArrayList<>(stringPair))));
                continue;
            }

            matchIndices.sort(Integer::compareTo);

            if (matchIndices.size() == 1) {
                newDictionary.get(matchIndices.get(0)).addAll(new ArrayList<>(stringPair));
            } else {
                int last = matchIndices.remove(0);
                while (matchIndices.size() > 0) {
                    int i = matchIndices.get(0);
                    newDictionary.get(last).addAll(newDictionary.get(i));
                    newDictionary.remove(i);
                    matchIndices.remove(0);
                    matchIndices = new ArrayList<>(matchIndices.stream().map(a -> a - 1).toList());
                }
            }
        }
        newDictionary = newDictionary.stream()
                .map(strings -> strings.stream().distinct().toList())
                .toList();

        return newDictionary;
    }

它是如何工作的？

• dictionary List<List<String>> 类型的输入(内部列表的最大大小为 2，即使理论上该函数可以处理更多字符串)
• newDictionary List<List<String>> 类型函数的输出

以下代码针对 directory 中的每个输入对/字符串列表执行

1. 获取newDictionary 中所有现有的不同“组”(它们的索引)其中 par 中的字符串已经存在。此索引列表称为 matchIndices
   示例:stringPair =[“A”，“E”] newDictionary :[["I", "A", "O"], ["P", "D"]] 将导致 matchIndices =[0] 因为在 newDictionary 的第一个元素中只有“A”出现一次
2. 如果matchIndices.size()为0，在newDictionary中新建一个组与字符串对。回到 1。
3. 如果matchIndices.size()为 1，将对中的字符串附加到特定的 newDictionary使用 matchIndices 中指定的索引进行分组.回到 1。
4. 如果matchIndices.size()大于 1，这意味着来自 newDictionary 的多个组使用 matchIndices 中指定的索引必须在 for 中合并在一起-环形。回到 1。

最后我们必须确保 newDictionary 中的列表中没有重复项.

主要方法

    public static void main(String[] args) {
        List<List<String>> dictionary = new ArrayList<>(List.of(
                List.of("A", "B"),
                List.of("B", "C"),
                List.of("D", "E"),
                List.of("F", "C"),
                List.of("G", "H"),
                List.of("T", "D")));
        
        System.out.println(merge(dictionary));
    }

为什么我们需要第 4 步？

在您的具体示例中，我们不必合并多个组。
但是像这样的输入数据

List<List<String>> dictionary = new ArrayList<>(List.of(
                List.of("A", "B"),
                List.of("B", "C"),
                List.of("D", "E"),
                List.of("F", "E"),
                List.of("E", "A")));

我们最终来到了 newDictionary=[[A, B, B, C], [D, E, F, E]] 的地步我们必须尝试插入 [E, A] .这里两组来自 newDictionary将不得不合并在一起。
这将导致输出 [[A, B, C, D, E, F]] ，其中两个组被合并并删除了重复项。

附言

我对这个解决方案不是很满意，因为它并不清楚到底发生了什么，但我仍然发布这个，因为你说过你会对任何解决方案感到满意。 :)