Java-查找最大大小的哈希表

我有以下数据结构：

Map<Integer, Map<String,Double>>

----------------
|     | a    2 |
| 100 | b    1 |    
|     | c    2 |
----------------
|     | a    2 |
| 101 | c    2 |    
----------------
|     | a    2 |
| 102 | b    1 |    
|     | c    2 |
----------------

Map
----------------
|| a 2|
|100 | b 1 |
|| c2|
----------------
|| a 2|
|101 | c2 |
----------------
|| a 2|
|102 | b 1 |
|| c2|
----------------

目标：获取包含最大大小的内部映射的外部映射的ID

例如，

100

或

102

，两者都包含大小为3的内部贴图

例如，如何使用

流API

map.values().stream().max(Comparator.comparingInt(Map::size)).get()

这就是你要找的

map.keySet().stream().max(Comparator.comparingInt(k -> map.get(k).size()))

如果你想要的是钥匙，而不是地图。 测试代码：

Map<Integer, Map<String, Integer>> map = new HashMap<>();
        Map<String, Integer> map2 = new HashMap<>();
        map2.put("A", 1);
        map2.put("B", 2);
        map2.put("C", 3);
        map.put(100, map2);
        map2 = new HashMap<>();
        map2.put("A", 1);
        map2.put("B", 2);
        map.put(101, map2);
        System.out.println(map.values()
                              .stream()
                              .max(Comparator.comparingInt(Map::size)).get());

Map Map=newhashmap（）；
Map map2=新的HashMap（）；
map2.put（“A”，1）；
map2.put（“B”，2）；
map2.put（“C”，3）；
地图放置（100，地图2）；
map2=新的HashMap（）；
map2.put（“A”，1）；
map2.put（“B”，2）；
地图（101，地图2）；
System.out.println（map.values（）
.stream（）
.max（Comparator.comparingit（Map:：size））.get（）；

这将提供100的输出或具有最大元素的键

map.keySet().stream().max((v1, v2) -> {
                return Integer.compare(map.get(v1).size(), map.get(v2).size());
            })

或使用比较器

map.keySet().stream().max(Comparator.comparingInt(v -> map.get(v).size()))

完整代码：

Map<Integer,Map<String,Double>> map = new HashMap<>();
Map<String,Double> map100 = new HashMap<>();
map100.put("a", 2.0);
map100.put("b", 1.0);
map100.put("c", 2.0);
Map<String,Double> map101 = new HashMap<>();
map101.put("a", 2.0);
map101.put("b", 1.0);
Map<String,Double> map102 = new HashMap<>();
map102.put("a", 2.0);
map102.put("b", 1.0);
map102.put("c", 2.0);
map102.put("d", 2.0);
map.put(100, map100);
map.put(101, map101);
map.put(102, map102);

System.out.println(map.keySet().stream().max(Comparator.comparingInt(v -> map.get(v).size())));

System.out.println(map.keySet().stream().max((v1, v2) -> {
    return Integer.compare(map.get(v1).size(), map.get(v2).size());
}));

Map Map=newhashmap（）；
Map map100=新的HashMap（）；
map100.put（“a”，2.0）；
map100.put（“b”，1.0）；
map100.put（“c”，2.0）；
Map map101=新的HashMap（）；
map101.put（“a”，2.0）；
map101.put（“b”，1.0）；
Map map102=新HashMap（）；
map102.put（“a”，2.0）；
map102.put（“b”，1.0）；
map102.put（“c”，2.0）；
map102.put（“d”，2.0）；
地图放置（100，地图100）；
地图放置（101，地图101）；
地图放置（102，地图102）；
System.out.println（map.keySet（）.stream（）.max（Comparator.comparingInt（v->map.get（v.size（））））；
System.out.println（map.keySet（）.stream（）.max（（v1，v2）->{
返回Integer.compare（map.get（v1.size（），map.get（v2.size（））；
}));

要获取任何具有最大映射值的条目的外部映射键，代码可以是：

int id = map.entrySet()
    .stream()
    .max(Map.Entry.comparingByValue(Comparator.comparingInt(Map::size)))
    .get() // May throw a NoSuchElementException if there is no max
    .getKey();

另一种方法允许将值获取为

可选

，例如，当映射为空时，如果没有max，则可以避免获取

NoSuchElementException

Optional<Integer> id = map.entrySet()
    .stream()
    .max(Map.Entry.comparingByValue(Comparator.comparingInt(Map::size)))
    .map(Map.Entry::getKey);

Optional id=map.entrySet（）
.stream（）
.max（Map.Entry.comparingByValue（Comparator.comparingInt（Map:：size）））
.map（map.Entry:：getKey）；

---

---

请注意，这些方法比遍历键并调用

map.get（k）.size（）更有效

获取内部映射的大小，因为您进行了不必要的映射查找，而这些查找是按照这些方法直接迭代条目时不做的。

到目前为止您做了哪些尝试？@khelwood I迭代了外部映射键，保存内部映射的大小和相应的外部ID。但是我有大约20000个键：这个过程非常慢，所以我需要一个更快的方法。这是一个不错的开始。我猜每次查找所有键都非常耗时。内部地图是独立访问还是仅通过外部地图访问？即，您是否可以控制何时在单个位置添加/删除内部地图？如果是这样的话，您可以有一个对max的引用，并在每次添加/删除到内部映射时更新它。。。很多“如果”仍然…@Tunaki he不：）

100或102

只有一个值就足够了，因为我有以下假设：两个大小相同的外部映射有两个具有相同键的内部映射。@Fab得到的映射足够了，或者你更喜欢索引？但是返回的映射不再包含键了，对吗？就像100或102条信息丢失一样。@BandiKishore是的，对你的答案投了赞成票。这样更好。我将重点放在地图本身上，注意这会为更大的地图生成大量的散列查找。如果您知道需要键和值，那么首先应该迭代

入口集

，而不是迭代

键集

，并对每个键进行查找。也就是说，

map.entrySet（）.stream（）.max（map.Entry.comparingByValue（Comparator.comparingit（map:：size）））.map（map.Entry:：getKey）

Holger-很好的建议，这确实会导致大量不必要的查找，可以避免@Nicolas给出了一个很好的例子来解释这一点。您也可以使用

Map.Entry.comparingByValue（Comparator.comparingit（Map:：size））

作为比较器。如果不能保证存在最大值（即映射可能为空），则将

.get（）.getKey（）

替换为

.map（map.Entry:：getKey）

以获取

可选的
。