Java 在列表中合并树映射

我有一个

列表

，其中包含以下地图

Map:{clusterList=[71051], senseId=65786, totalCluster=1}
Map:{clusterList=[71051], senseId=65787, totalCluster=1}
Map:{clusterList=[4985, 71052], senseId=65788, totalCluster=2}
Map:{clusterList=[125840,153610,167812, 65787, 204091, 32586, 65786], senseId=71051, totalCluster=7}
Map:{clusterList=[11470, 65788], senseId=71052, totalCluster=2} 

我已经遍历了地图并检查了集群列表中是否存在senseId。但是，使用senseId遍历每个clusterList与传统的for循环相比需要很长时间，而且我无法获得如下所示的合并列表

Map:{clusterList=[125840,153610,167812, 65787, 204091, 32586, 65786], senseId=71051, totalCluster=7}
Map:{clusterList=[4985,11470, 65788], senseId=71052, totalCluster=2}

我甚至无法删除clusterList中存在sensId的映射，因为它作为并发操作异常抛出

除了for循环之外，还有什么办法可以得到结果呢？因为这个列表非常小，所以for循环仍然有效。但我有180个地图条目的列表，很难遍历整个列表并合并地图

---

我被卡住了，因为一个地图的senseId出现在另一个地图的clusterList中。所以不能用简单的搜索来合并它们

我相当肯定这个问题还没有明确说明。例如，不清楚如何决定最终的

senseId

。当你有两张地图时

Map:{clusterList=[123,456,789], senseId=123, totalCluster=1}
Map:{clusterList=[123,456,666], senseId=456, totalCluster=1}

然后（如果我理解正确的话）它们应该合并。但目前尚不清楚结果是否应该是一张地图

Map:{clusterList=[123,456,789,666], senseId=123, totalCluster=1}

还是地图

Map:{clusterList=[123,456,789,666], senseId=456, totalCluster=1}

除此之外，“totalCluster”似乎是集群列表的大小。这意味着它很可能是不必要的，如果不是不必要的，则必须指定在合并两个贴图时应如何处理它

然而，这里有一个基本的方法：可以创建一个从

senseId

到使用该

senseId

的映射的映射，然后收集在其集群列表中包含特定

senseId

的映射，以找出必须合并的映射

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;


public class MapMergeTest
{
    public static void main(String[] args)
    {
        List<Map<String, Object>> maps = createInput();

        System.out.println("Input:");
        for (Map<String, Object> map : maps)
        {
            System.out.println(map);
        }

        List<Map<String, Object>> result = createMergedMapsList(maps);

        System.out.println("Result:");
        for (Map<String, Object> map : result)
        {
            System.out.println(map);
        }
    }


    private static List<Map<String, Object>> createInput()
    {
        List<Map<String, Object>> maps = new ArrayList<Map<String, Object>>();
        //                senseId  clusterList...
        maps.add(createMap(65786,  71051));
        maps.add(createMap(65787,  71051));
        maps.add(createMap(65788,  4985, 71052));
        maps.add(createMap(71051,  125840, 153610, 167812, 
            65787, 204091, 32586, 65786));
        maps.add(createMap(71052,  11470, 65788));
        return maps;
    }
    private static Map<String, Object> createMap(
        Integer senseId, Integer ... clusters)
    {
        Map<String, Object> result = new LinkedHashMap<String, Object>();
        result.put("senseId", senseId);
        result.put("clusterList", new ArrayList<Integer>(Arrays.asList(clusters)));
        return result;
    }



    private static List<Map<String, Object>> createMergedMapsList(
        List<Map<String, Object>> maps)
    {
        Map<Integer, Map<String, Object>> senseIdToMap =
            createSenseIdToMap(maps);

        Map<Integer, Map<String, Object>> copy = 
            new LinkedHashMap<Integer, Map<String,Object>>(senseIdToMap);
        for (Entry<Integer, Map<String, Object>> e : copy.entrySet())
        {
            Integer senseId = e.getKey();
            Map<String, Object> map = e.getValue();
            List<Integer> clusterList = getClusterList(map);
            List<Map<String, Object>> mapsToMerge = 
                new ArrayList<Map<String,Object>>();
            mapsToMerge.add(map);
            for (Integer cluster : clusterList)
            {
                Map<String, Object> mapToMerge =
                    senseIdToMap.get(cluster);
                if (mapToMerge != null)
                {
                    mapsToMerge.add(mapToMerge);
                    senseIdToMap.remove(cluster);
                }
            }
            if (mapsToMerge.size() > 1)
            {
                Map<String, Object> mergedMap = mergeMaps(mapsToMerge);
                List<Integer> mergedClusterList = getClusterList(mergedMap);
                mergedClusterList.remove(senseId);
                senseIdToMap.put(senseId, mergedMap);
            }
        }
        return new ArrayList<Map<String,Object>>(senseIdToMap.values());
    }

    private static Map<Integer, Map<String, Object>> createSenseIdToMap(
        List<Map<String, Object>> maps)
    {
        Map<Integer, Map<String, Object>> senseIdToMap = 
            new LinkedHashMap<Integer, Map<String,Object>>();
        for (Map<String, Object> map : maps)
        {
            Integer senseId = (Integer)map.get("senseId");
            senseIdToMap.put(senseId, map);
        }
        return senseIdToMap;
    }

    private static Map<String, Object> mergeMaps(List<Map<String, Object>> list)
    {
        Map<String, Object> mergedMap = new LinkedHashMap<String, Object>();
        Map<String, Object> firstMap = list.get(0);
        mergedMap.put("senseId", firstMap.get("senseId"));
        Set<Integer> mergedClusterList = new LinkedHashSet<Integer>();
        for (Map<String, Object> map : list)
        {
            List<Integer> clusterList = getClusterList(map);
            mergedClusterList.addAll(clusterList);
        }
        mergedMap.put("clusterList", new ArrayList<Integer>(mergedClusterList));
        return mergedMap;
    }


    private static List<Integer> getClusterList(Map<String, Object> map)
    {
        Object object = map.get("clusterList");
        return (List<Integer>)object;
    }

}

import java.util.ArrayList；
导入java.util.array；
导入java.util.LinkedHashMap；
导入java.util.LinkedHashSet；
导入java.util.List；
导入java.util.Map；
导入java.util.Map.Entry；
导入java.util.Set；
公共类映射合并测试
{
公共静态void main（字符串[]args）
{
列表映射=createInput（）；
System.out.println（“输入：”）；
用于（地图：地图）
{
系统输出打印项次（map）；
}
列表结果=createMergedMapsList（地图）；
System.out.println（“结果：”）；
用于（映射：结果）
{
系统输出打印项次（map）；
}
}
私有静态列表createInput（）
{
列表映射=新建ArrayList（）；
//senseId群集列表。。。
添加（createMap（6578671051））；
添加（createMap（6578771051））；
添加（createMap（6578849871052））；
添加（createMap（7105112584015361167812，
65787, 204091, 32586, 65786));
添加（createMap（710521147065788））；
返回地图；
}
私有静态映射createMap(
整数senseId，整数…群集）
{
映射结果=新建LinkedHashMap（）；
结果。放置（“senseId”，senseId）；
put（“clusterList”，新的ArrayList（Arrays.asList（clusters））；
返回结果；
}
私有静态列表createMergedMapsList(
列表（地图）
{
地图感应地图=
CreateSenseIDomap（地图）；
地图副本=
新LinkedHashMap（senseIdToMap）；
对于（条目e:copy.entrySet（））
{
整数senseId=e.getKey（）；
Map Map=e.getValue（）；
List clusterList=getClusterList（map）；
列表映射合并=
新的ArrayList（）；
mapsToMerge.add（map）；
用于（整型群集：群集列表）
{
地图制图机=
senseIdToMap.get（集群）；
if（mapToMerge！=null）
{
mapsToMerge.add（mapToMerge）；
senseIdToMap.remove（集群）；
}
}
如果（mapsToMerge.size（）>1）
{
Map mergedMap=mergeMaps（mapsToMerge）；
List mergedClusterList=getClusterList（mergedMap）；
mergedClusterList.remove（senseId）；
senseIdToMap.put（senseId，mergedMap）；
}
}
返回新的ArrayList（senseIdToMap.values（））；
}
私有静态映射CreateSenseIDomap(
列表（地图）
{
映射senseIdToMap=
新建LinkedHashMap（）；
用于（地图：地图）
{
整数senseId=（整数）map.get（“senseId”）；
senseIdToMap.put（senseId，map）；
}
返回感测图；
}
私有静态映射合并映射（列表）
{
Map mergedMap=newlinkedhashmap（）；
Map firstMap=list.get（0）；
mergedMap.put（“senseId”，firstMap.get（“senseId”）；
Set mergedClusterList=newlinkedhashset（）；
用于（地图：列表）
{
List clusterList=getClusterList（map）；
mergedClusterList.addAll（clusterList）；
}
mergedMap.put（“clusterList”，新的ArrayList（mergedClusterList））；
返回合并地图；
}
私有静态列表getClusterList（映射）
{
Object=map.get（“clusterList”）；
返回（列表）对象；
}
}

这样您就有了给定的地图列表。每个映射包含键

“clusterList”

（其值为整数列表）和

“senseId”

（其值为单个整数）。而且。。。你现在想做什么？查找具有特定<代码>senseId的所有地图？这不是你贴的。。。查找

clusterList

中包含

senseID

的所有地图？这也不是你发布的…我想把这5张地图合并成两张地图。不必担心clusterList中的值是整数还是字符串。把它当作价值。如您所见，第一个地图senseId是65786，它已经存在于第四个地图的clusterList中。所以我想保留这个senseId 71051，因为它的clusterList具有前3个贴图的senseId，并合并前3个贴图。概念是senseId在clusterList中有它的链接，因此复制了sh