Java 将贴图值分组以避免重复

我有一个Map（map1），它的键是另一个Map（map2），值是string

map1的值有几个重复项，所以我必须将它们分组，并在另一个map3中设置为key，该map3的值必须是map2

eg:

map1 {  [[a,b],xyz],  [[c,d],wrt] , [[e,f],xyz] , [[r,m],xyz]  }


output should be :

map3 {  [ xyz,[ [a,b],[e,f],[r,m] ] ]  , [ wrt,[ [c,d] ]

我可以这样获得吗？

尝试从（commons collections）库获取多值映射

Map map1=newhashmap（）；
map1.put（新字符串[]{“a”，“b”}，“xyz”）；
map1.put（新字符串[]{“c”，“d”}，“wrt”）；
map1.put（新字符串[]{“e”，“f”}，“xyz”）；
map1.put（新字符串[]{“c”，“d”}，“xyz”）；
MultiValueMap map2=新的MultiValueMap（）；
对于（字符串[]键：map1.keySet（））{
字符串值=map1.get（键）；
map2.add（值、键）；
}
//现在你得到了你想要的地图2

否，尽管您可以声明它，但在使用它时，它可能允许使用相同的密钥（人类可读）。由于

Map

不会覆盖

Object

的equals方法，因此关键比较将在JVM的对象级别上进行（对于具有相同值的对象可能会有所不同）。

您可以使用流API来解决此问题：

Map<String, List<Map<String, String>>> map3 = map.entrySet().stream()
    .collect(Collectors.groupingBy(Entry::getValue,
                                   Collectors.mapping(Entry::getKey,
                                                      Collectors.toList())));

Map map3=Map.entrySet（）.stream（）
.collect（收集器）.groupingBy（条目：：getValue，
Collectors.mapping（条目：：getKey，
收藏家；

说明： 条目将按其值分组（

groupingBy（Entry:：getValue

）。

---

但是这些值不应该是条目列表，因此下游是必需的。这是原始地图的键列表。

从您的帖子中不清楚您所说的

map2

是什么意思，但是让我们假设您希望为

map1

的每个键使用

map.Entry条目
from
map2

下面的代码是Java7，有点冗长。我想用Java8流可以做得更短

public class MapReverser {

    private Map<Map.Entry<String, String>, String> map1 = new HashMap<>();

    private Map<String, String> map2 = new LinkedHashMap<>();

    private void prepareMaps() {
        map2.put("a", "b");
        map2.put("c", "d");
        map2.put("e", "f");
        map2.put("r", "m");

        String[] valueArray = { "xyz", "wrt", "xyz", "xyz" };
        int i = 0;
        for (Map.Entry<String, String> entry : map2.entrySet()) {
            map1.put(entry, valueArray[i]);
            i++;
        }
    }

    public Map<String, List<Map.Entry<String, String>>> reverse() {
        Map<String, List<Map.Entry<String, String>>> reversedMap = new HashMap<>();
        for (Map.Entry<Map.Entry<String, String>, String> entry : map1.entrySet()) {
            List<Map.Entry<String, String>> reversedMapValue = reversedMap.get(entry.getValue());
            if (reversedMapValue == null) {
                reversedMapValue = new ArrayList<>();
            }
            reversedMapValue.add(entry.getKey());
            reversedMap.put(entry.getValue(), reversedMapValue);
        }
        return reversedMap;
    }

    private void printResult(Map<String, List<Map.Entry<String, String>>> reversedMap) {
        for (Map.Entry<String, List<Map.Entry<String, String>>> entry : reversedMap.entrySet()) {
            System.out.println("Key: \n" + entry.getKey());
            System.out.println("Values:");
            List<Map.Entry<String, String>> valuesList = entry.getValue();
            for (Map.Entry<String, String> value : valuesList) {
                System.out.println(value );
            }
            System.out.println("\n");
        }
    }

    public static void main(String[] args) {
        MapReverser mapReverser = new MapReverser();
        mapReverser.prepareMaps();
        Map<String, List<Map.Entry<String, String>>> reversedMap = mapReverser.reverse();
        mapReverser.printResult(reversedMap);
    }
}

公共类映射反向器{
私有映射map1=新的HashMap（）；
private Map map2=新建LinkedHashMap（）；
私有无效制备映射（）{
map2.put（“a”、“b”）；
map2.put（“c”、“d”）；
map2.put（“e”、“f”）；
map2.put（“r”、“m”）；
字符串[]valueArray={“xyz”，“wrt”，“xyz”，“xyz”}；
int i=0；
对于（Map.Entry:map2.entrySet（））{
map1.put（条目，valueArray[i]）；
i++；
}
}
公共地图反向（）{
Map reversedMap=newhashmap（）；
对于（Map.Entry:map1.entrySet（））{
List reversedMapValue=reversedMap.get（entry.getValue（））；
如果（reversedMapValue==null）{
reversedMapValue=新的ArrayList（）；
}
reversedMapValue.add（entry.getKey（））；
reversedMap.put（entry.getValue（），reversedMapValue）；
}
返回反向映射；
}
私有void打印结果（映射反向映射）{
对于（Map.Entry:reversedMap.entrySet（））{
System.out.println（“Key:\n”+entry.getKey（））；
System.out.println（“值：”）；
列表值列表=entry.getValue（）；
for（Map.Entry值：valuesList）{
系统输出打印项次（值）；
}
System.out.println（“\n”）；
}
}
公共静态void main（字符串[]args）{
MapReverser MapReverser=新的MapReverser（）；
mapReverser.prepareMaps（）；
Map reversedMap=mapReverser.reverse（）；
mapReverser.printResult（reversedMap）；
}
}
您可以将第一张地图转换为一个集合，并将其与map2结合起来用于map3。您的目标是将
键
与
值
反向，因此如果map1是
地图
您希望从该地图1中获得
地图
，它似乎是一个列表，我认为您应该更清楚地表述您的问题。是否应该“map3{[xyz，[[a，b]，[e，f]，[r，m]]，[wrt，[[c，d]]“未阅读”map2{[xyz，[[a，b]，[e，f]，[r，m]]，[wrt，[[c，d]]“？输入错误？我看不到多值映射到OP的情况的相关性更新了详细代码。我看到了相关性：）
Map
是一个接口，为什么它要覆盖
equals
。顺便说一句：
AbstractMap
覆盖
equals
和
java.util
扩展这个类的大部分（或全部？）实现。这里
Map
是（我认为很明显）一个可靠的
Map
接口实现。您将不会创建另一个
Map
实现，因此您将无法编辑以前JAVA提供的用于覆盖
equals
的实现。这就是答案为否的原因
public class MapReverser {

    private Map<Map.Entry<String, String>, String> map1 = new HashMap<>();

    private Map<String, String> map2 = new LinkedHashMap<>();

    private void prepareMaps() {
        map2.put("a", "b");
        map2.put("c", "d");
        map2.put("e", "f");
        map2.put("r", "m");

        String[] valueArray = { "xyz", "wrt", "xyz", "xyz" };
        int i = 0;
        for (Map.Entry<String, String> entry : map2.entrySet()) {
            map1.put(entry, valueArray[i]);
            i++;
        }
    }

    public Map<String, List<Map.Entry<String, String>>> reverse() {
        Map<String, List<Map.Entry<String, String>>> reversedMap = new HashMap<>();
        for (Map.Entry<Map.Entry<String, String>, String> entry : map1.entrySet()) {
            List<Map.Entry<String, String>> reversedMapValue = reversedMap.get(entry.getValue());
            if (reversedMapValue == null) {
                reversedMapValue = new ArrayList<>();
            }
            reversedMapValue.add(entry.getKey());
            reversedMap.put(entry.getValue(), reversedMapValue);
        }
        return reversedMap;
    }

    private void printResult(Map<String, List<Map.Entry<String, String>>> reversedMap) {
        for (Map.Entry<String, List<Map.Entry<String, String>>> entry : reversedMap.entrySet()) {
            System.out.println("Key: \n" + entry.getKey());
            System.out.println("Values:");
            List<Map.Entry<String, String>> valuesList = entry.getValue();
            for (Map.Entry<String, String> value : valuesList) {
                System.out.println(value );
            }
            System.out.println("\n");
        }
    }

    public static void main(String[] args) {
        MapReverser mapReverser = new MapReverser();
        mapReverser.prepareMaps();
        Map<String, List<Map.Entry<String, String>>> reversedMap = mapReverser.reverse();
        mapReverser.printResult(reversedMap);
    }
}