Java 排序HashMap及其嵌套HashMap

我正在尝试对嵌套的hashMaps进行排序，其中两个hashMaps都需要排序

第一个hashMap应该按键排序。第二个应该按值排序。 到目前为止，我通过制作一个键数组并对其排序，成功地对第一个hashMap的键进行排序

我的hashmap看起来像这样

 HashMap<String,HashMap<String,Integer>> carOwners = new 
                                    HashMap<String,HashMap<String, Integer>>();

HashMap车主=新建
HashMap（）；

例如，假设我们的第一个字符串是名称、汽车品牌、qnty

例如： 大卫：

奥迪>5

宝马>4

伊扎贝尔：

VW>10

MB>4

---

因此，基本上我们首先对名称进行排序，然后根据值对嵌套哈希进行排序。如何做到这一点。。。找不到任何有用的信息：（>

要对

地图进行排序，可以使用以下类：
TreeMap

映射根据其键的自然顺序进行排序，或者由映射创建时提供的比较器进行排序，具体取决于使用的构造函数

如果要按插入顺序对元素排序，请使用

此链表定义了迭代顺序，通常是将关键帧插入贴图的顺序（插入顺序）

有关按值对
映射进行排序的信息，请参见此。它也适用于Java7和Java8

希望有帮助。
要对
地图进行排序，可以使用以下类：
TreeMap

映射根据其键的自然顺序进行排序，或者由映射创建时提供的比较器进行排序，具体取决于使用的构造函数

如果要按插入顺序对元素排序，请使用

此链表定义了迭代顺序，通常是将关键帧插入贴图的顺序（插入顺序）

有关按值对
映射进行排序的信息，请参见此。它也适用于Java7和Java8

希望有帮助。
将第一个映射作为树映射，对于第二个映射，请按值对其进行排序。请参阅此

下面是针对您的问题的代码片段

public static void main(String[] args) {
    Map<String, HashMap<String, Integer>> carOwners = new TreeMap<String, HashMap<String, Integer>>();
    HashMap<String, Integer> nameQuantity = new HashMap<String, Integer>();
    nameQuantity.put("Audi", 5);
    nameQuantity.put("BMW", 4);
    carOwners.put("David", sortByValue(nameQuantity)); 
    nameQuantity = new HashMap<String, Integer>();
    nameQuantity.put("VW", 10);
    nameQuantity.put("MB", 4);
    carOwners.put("Izabel", sortByValue(nameQuantity)); 
    for (Map.Entry<String, HashMap<String, Integer>> carOwnerEntry : carOwners.entrySet()) {
        System.out.println(carOwnerEntry.getKey());
        HashMap<String, Integer> nameQty = carOwnerEntry.getValue();
        for (Map.Entry<String, Integer> nameQtyEntry : nameQty.entrySet()) {
            System.out.println(nameQtyEntry.getKey() + " " + nameQtyEntry.getValue());
        }
    }

public static <K, V extends Comparable<? super V>> HashMap<K, V> sortByValue(Map<K, V> map) {
    List<Map.Entry<K, V>> list = new LinkedList<Map.Entry<K, V>>(map.entrySet());
    Collections.sort(list, new Comparator<Map.Entry<K, V>>() {
        public int compare(Map.Entry<K, V> o1, Map.Entry<K, V> o2) {
            return (o1.getValue()).compareTo(o2.getValue());
        });
    HashMap<K, V> result = new LinkedHashMap<K, V>();
    for (Map.Entry<K, V> entry : list) {
        result.put(entry.getKey(), entry.getValue());
    }
    return result;
}

publicstaticvoidmain（字符串[]args）{
映射车主=新树映射（）；
HashMap nameQuantity=新HashMap（）；
名称数量。放置（“奥迪”，5）；
名称数量。放置（“宝马”，4）；
carowner.put（“David”，sortByValue（nameQuantity））；
nameQuantity=新的HashMap（）；
名称数量。投入（“大众”，10）；
名称数量。放置（“MB”，4）；
carowner.put（“Izabel”，sortByValue（nameQuantity））；
对于（Map.Entry carOwnerEntry:carOwners.entrySet（））{
System.out.println（carOwnerEntry.getKey（））；
HashMap nameQty=carOwnerEntry.getValue（）；
对于（Map.Entry nameQtyEntry:nameQty.entrySet（））{
System.out.println（nameQtyEntry.getKey（）+“”+nameQtyEntry.getValue（））；
}
}
publicstatic将第一个映射设为TreeMap，对于第二个映射，按值对其进行排序。请参阅

下面是针对您的问题的代码片段

public static void main(String[] args) {
    Map<String, HashMap<String, Integer>> carOwners = new TreeMap<String, HashMap<String, Integer>>();
    HashMap<String, Integer> nameQuantity = new HashMap<String, Integer>();
    nameQuantity.put("Audi", 5);
    nameQuantity.put("BMW", 4);
    carOwners.put("David", sortByValue(nameQuantity)); 
    nameQuantity = new HashMap<String, Integer>();
    nameQuantity.put("VW", 10);
    nameQuantity.put("MB", 4);
    carOwners.put("Izabel", sortByValue(nameQuantity)); 
    for (Map.Entry<String, HashMap<String, Integer>> carOwnerEntry : carOwners.entrySet()) {
        System.out.println(carOwnerEntry.getKey());
        HashMap<String, Integer> nameQty = carOwnerEntry.getValue();
        for (Map.Entry<String, Integer> nameQtyEntry : nameQty.entrySet()) {
            System.out.println(nameQtyEntry.getKey() + " " + nameQtyEntry.getValue());
        }
    }

public static <K, V extends Comparable<? super V>> HashMap<K, V> sortByValue(Map<K, V> map) {
    List<Map.Entry<K, V>> list = new LinkedList<Map.Entry<K, V>>(map.entrySet());
    Collections.sort(list, new Comparator<Map.Entry<K, V>>() {
        public int compare(Map.Entry<K, V> o1, Map.Entry<K, V> o2) {
            return (o1.getValue()).compareTo(o2.getValue());
        });
    HashMap<K, V> result = new LinkedHashMap<K, V>();
    for (Map.Entry<K, V> entry : list) {
        result.put(entry.getKey(), entry.getValue());
    }
    return result;
}

publicstaticvoidmain（字符串[]args）{
映射车主=新树映射（）；
HashMap nameQuantity=新HashMap（）；
名称数量。放置（“奥迪”，5）；
名称数量。放置（“宝马”，4）；
carowner.put（“David”，sortByValue（nameQuantity））；
nameQuantity=新的HashMap（）；
名称数量。投入（“大众”，10）；
名称数量。放置（“MB”，4）；
carowner.put（“Izabel”，sortByValue（nameQuantity））；
对于（Map.Entry carOwnerEntry:carOwners.entrySet（））{
System.out.println（carOwnerEntry.getKey（））；
HashMap nameQty=carOwnerEntry.getValue（）；
对于（Map.Entry nameQtyEntry:nameQty.entrySet（））{
System.out.println（nameQtyEntry.getKey（）+“”+nameQtyEntry.getValue（））；
}
}
公共静态不能排序<代码> HashMap < /代码>，请考虑使用<代码> LinkedHashMap <代码>，根据代码< HashMap > <代码>它们没有排序。你是什么意思排序？@ TuyYnGuangY<代码> LinkedHashMap <代码>是<代码> HashMap >代码>技术上，你也不能对<代码> LinkedHashMap <代码>进行排序。@ DavidsAmause说真的。你为什么要这样做？“Seriossly无法对HashMap进行排序？”-是的。说真的。“这是我解决问题的唯一方法…”-你需要重新思考你的问题。总是有选择的。例如，不要使用<代码> HashMap < /代码>作为你唯一的数据结构。你不能对<代码> HashMap < /代码>进行排序，请考虑使用<代码> LinkedHashMap < /Cord>。uyen
LinkedHashMap
是一个
HashMap
。从技术上讲，你也不能对
LinkedHashMap
进行排序。@DavidsAmause严肃地说。你为什么要这样做呢？“Seriossly不能对HashMap进行排序？”-是的。严肃地说。“这是我解决问题的唯一办法…”-嗯，你需要重新思考你的问题。总有其他选择。例如，不要使用
HashMap
作为你唯一的数据结构。你找到它了吗？你找到它了吗？