java - 合并列表中的树形图

Question

我有一个List<Map<String, Object>>其中包含以下 map 。

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} 

我已经遍历了 map 并检查了 senseId 是否存在于 clusterList 中。但是使用 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 的 map ，因为它会抛出并发操作异常。

除了 for 循环之外，还有如何获得结果的任何想法，因为这个列表非常小，所以 for 循环仍然有效。但我的列表有 180 个 map 条目，很难遍历整个列表并合并 map 。

我被卡住了，因为一张 map 的 senseId 存在于另一张 map 的 clusterList 中。所以无法通过简单的搜索将它们合并。

Answer 1

我相当确定问题仍未明确。例如，尚不清楚如何决定最终的senseId。当你有两张 map 时

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

那么(如果我理解正确的话)它们应该被合并。但尚不清楚结果是否应该是 map

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

或 map

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

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

但是，这是一种基本方法:可以创建从 senseId 到具有此 senseId 的 map 的映射，然后收集包含特定 的映射senseId 在他们的集群列表中，以便找出必须合并哪些 map 。

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;
    }

}