Java 如何根据树形图的值对其进行排序？

如何使用树映射的值而不是键对树映射进行排序？

交换值和键

---

更严重的是，请提供一些你想要实现的背景。也许在其他处理完成后进行排序就足够了。

您可以尝试在创建树映射时提供一个比较值而不是键的比较器

    final TreeMap<Integer,String> tree = new TreeMap<Integer,String>();
    tree.put(1, "1");
    tree.put(2, "2");
    tree.put(3, "3");
    tree.put(4, "4");

    final TreeMap<Integer,String> treeSortedByValues = new TreeMap<Integer,String>(new Comparator<Integer>()
    {
        public int compare(Integer o1, Integer o2)
        {
            return tree.get(o1).compareTo(tree.get(o2));
        }
    });
    treeSortedByValues.putAll(tree);

    for ( Entry<Integer, String> e : treeSortedByValues.entrySet() )
    {
        System.out.println(e.getKey() + ": " + e.getValue());
    }

final TreeMap tree=newtreemap（）；
tree.put（1，“1”）；
tree.put（2，“2”）；
tree.put（3，“3”）；
tree.put（4，“4”）；
最终TreeMap treeSortedByValues=新的TreeMap（新的比较器（）
{
公共整数比较（整数o1，整数o2）
{
返回tree.get（o1）.compareTo（tree.get（o2））；
}
});
treeSortedByValues.putAll（树）；
对于（条目e:treeSortedByValues.entrySet（））
{
System.out.println（e.getKey（）+“：”+e.getValue（））；
}

有一个：

此类保证映射 将按升序和键顺序 和升序值顺序，已排序 按照自然的顺序 键和值的类

---

它有一个Java5泛型端口。

您不能，因为TreeMap的比较器仅针对键运行，例如，请参见此

无论如何，您可以使用多个集合，使用树形图（或者更确切地说是HashMap）按键查找元素，并使用SortedSet对值进行迭代

您还可以使用两个集合。你想完成什么？您能解释一下您的用例吗？

这里有一个解决方案：

public static <K, V extends Comparable<V>> Map<K, V> sortByValues(final Map<K, V> map) {
    Comparator<K> valueComparator =  new Comparator<K>() {
        public int compare(K k1, K k2) {
            int compare = map.get(k2).compareTo(map.get(k1));
            if (compare == 0) return 1;
            else return compare;
        }
    };
    Map<K, V> sortedByValues = new TreeMap<K, V>(valueComparator);
    sortedByValues.putAll(map);
    return sortedByValues;
}

公共静态映射SortByValue（最终映射）{
比较器值比较器=新比较器（）{
公共整数比较（kk1，kk2）{
int compare=map.get（k2）.compareTo（map.get（k1））；
如果（比较==0）返回1；
否则返回比较；
}
};
Map sortedByValues=新树映射（valueComparator）；
sortedByValues.putAll（地图）；
返回SortedByValue；
}

---

请注意，映射是从最高值到最低值排序的。

请尝试下面的代码，这对我来说很好。您可以选择升序和降序进行排序

package com.rais;

import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

public class SortMapByValue
{
    public static boolean ASC = true;
    public static boolean DESC = false;

    public static void main(String[] args)
    {

        // Creating dummy unsorted map
        Map<String, Integer> unsortMap = new HashMap<String, Integer>();
        unsortMap.put("B", 55);
        unsortMap.put("A", 80);
        unsortMap.put("D", 20);
        unsortMap.put("C", 70);

        System.out.println("Before sorting......");
        printMap(unsortMap);

        System.out.println("After sorting ascending order......");
        Map<String, Integer> sortedMapAsc = sortByComparator(unsortMap, ASC);
        printMap(sortedMapAsc);


        System.out.println("After sorting descindeng order......");
        Map<String, Integer> sortedMapDesc = sortByComparator(unsortMap, DESC);
        printMap(sortedMapDesc);

    }

    private static Map<String, Integer> sortByComparator(Map<String, Integer> unsortMap, final boolean order)
    {

        List<Entry<String, Integer>> list = new LinkedList<Entry<String, Integer>>(unsortMap.entrySet());

        // Sorting the list based on values
        Collections.sort(list, new Comparator<Entry<String, Integer>>()
        {
            public int compare(Entry<String, Integer> o1,
                    Entry<String, Integer> o2)
            {
                if (order)
                {
                    return o1.getValue().compareTo(o2.getValue());
                }
                else
                {
                    return o2.getValue().compareTo(o1.getValue());

                }
            }
        });

        // Maintaining insertion order with the help of LinkedList
        Map<String, Integer> sortedMap = new LinkedHashMap<String, Integer>();
        for (Entry<String, Integer> entry : list)
        {
            sortedMap.put(entry.getKey(), entry.getValue());
        }

        return sortedMap;
    }

    public static void printMap(Map<String, Integer> map)
    {
        for (Entry<String, Integer> entry : map.entrySet())
        {
            System.out.println("Key : " + entry.getKey() + " Value : "+ entry.getValue());
        }
    }
}

package com.rais；
导入java.util.Collections；
导入java.util.Comparator；
导入java.util.HashMap；
导入java.util.LinkedHashMap；
导入java.util.LinkedList；
导入java.util.List；
导入java.util.Map；
导入java.util.Map.Entry；
公共类SortMapByValue
{
公共静态布尔值ASC=true；
公共静态布尔DESC=false；
公共静态void main（字符串[]args）
{
//创建虚拟未排序贴图
Map unsortMap=newhashmap（）；
不排序图。放置（“B”，55）；
反排序图。放置（“A”，80）；
反排序图。放置（“D”，20）；
反排序图。放置（“C”，70）；
System.out.println（“排序前……”）；
printMap（unsortMap）；
System.out.println（“升序排序后……”）；
Map sortedMapAsc=排序比较程序（unsortMap，ASC）；
印刷地图（分类地图）；
System.out.println（“排序后定义顺序……”）；
Map sortedMapDesc=sortByComparator（反排序图，DESC）；
打印地图（sortedMapDesc）；
}
私有静态映射sortByComparator（映射非排序映射，最终布尔顺序）
{
List=新的LinkedList（unsortMap.entrySet（））；
//根据值对列表进行排序
Collections.sort（list，newcomparator（）
{
公共整数比较（条目o1，
入口（氧气）
{
如果（订单）
{
返回o1.getValue（）.compareTo（o2.getValue（））；
}
其他的
{
返回o2.getValue（）.compareTo（o1.getValue（））；
}
}
});
//借助LinkedList维护插入顺序
Map sortedMap=new LinkedHashMap（）；
用于（条目：列表）
{
sortedMap.put（entry.getKey（），entry.getValue（））；
}
返回分拣的DMAP；
}
公共静态无效打印地图（地图地图）
{
for（条目：map.entrySet（））
{
System.out.println（“Key:+entry.getKey（）+”值：+entry.getValue（））；
}
}
}

这就是我所做的

package Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.TreeMap;

class MyComparator implements Comparator<Object> {

    public int compare(Object o1, Object o2) {
        return (((Integer) o2).compareTo((Integer) o1));
    }
}

class MyComparator1 implements Comparator<Object> {
    Map<Integer, String> map;

    public MyComparator1(Map<Integer, String> m) {
        this.map = m;
    }

    public int compare(Object o1, Object o2) {
        return (((String) map.get(o1)).compareTo((String) map.get(o2)));
    }
}

public class Map1 {
    public static void main(String[] args) {
        Map<Integer, String> hmap = new HashMap<Integer, String>();
        hmap.put(5, "Ashok");
        hmap.put(21, "Bhanu");
        hmap.put(7, "chaman");
        hmap.put(28, "dheeraj");
        hmap.put(761, "edison");
        hmap.put(1, "frank");
        hmap.put(-6, "gopal");
        hmap.put(78, "hari");
        System.out.println("Hash Map:" + hmap);
        Map<Integer, String> tmap = new TreeMap<>(hmap);
        System.out.println("Tree Map:" + tmap);
        MyComparator comp = new MyComparator();
        Map<Integer, String> itmap = new TreeMap<>(comp);
        itmap.putAll(hmap);
        System.out.println("Tree Map Inreverse order:" + itmap);
        Map<Integer, String> orderValuemap = new TreeMap<Integer, String>(new 
            MyComparator1(hmap));
            orderValuemap.putAll(hmap);
            orderValuemap.put(22,"hello");
        for(Entry<Integer, String> mp:orderValuemap.entrySet())
            System.out.println("Value : "+mp.getValue());
    }
}

package集合；
导入java.util.Comparator；
导入java.util.HashMap；
导入java.util.Map；
导入java.util.Map.Entry；
导入java.util.TreeMap；
类MyComparator实现比较器{
公共整数比较（对象o1、对象o2）{
返回（（整数）o2.compareTo（（整数）o1））；
}
}
类MyComparator1实现了Comparator{
地图；
公共MyComparator1（地图m）{
这个.map=m；
}
公共整数比较（对象o1、对象o2）{
return（（（String）map.get（o1））.compareTo（（String）map.get（o2））；
}
}
公共类Map1{
公共静态void main（字符串[]args）{
Map hmap=newhashmap（）；
hmap.put（5，“Ashok”）；
hmap.put（21，“Bhanu”）；
hmap.put（7，“查曼”）；
hmap.put（28，“dheeraj”）；
hmap.put（761，“爱迪生”）；
hmap.put（1，“弗兰克”）；
hmap.put（-6，“gopal”）；
hmap.put（78，“哈里”）；
System.out.println（“哈希映射：+hmap”）；
Map tmap=新树映射（hmap）；
System.out.println（“树映射：+tmap”）；
MyComparator comp=新的MyComparator（）；
Map itmap=新树映射（comp）；
itmap.putAll（hmap）；
System.out.println（“倒序树映射：+itmap”）；
Map orderValuemap=newtreemap（new
MyComparator1（hmap））；
orderValuemap.putAll（hmap）；
orderValuemap.put（22，“你好”）；
对于（条目mp:orderValuemap.entrySet（））
System.out.println（“值：+mp.getValue（））；
}
}

试试这个。这将按升序对树映射值进行排序，假设您希望按升序对值进行排序

static <K, V> Map<K, V> sortByValues(Map<K, V> map) {
        List<?> list = new ArrayList(map.entrySet());

        // copy Map to List to use Comparator
        Collections.sort(list, new Comparator() {
            public int compare(Object o1, Object o2) {
                return ((Comparable) ((Map.Entry) o1).getValue()).compareTo(((Map.Entry) o2).getValue());
            }
        });

        // then copy List to LinkedHashMap as it preserves insertion order
        Map<K, V> result = new LinkedHashMap<K, V>();
        Iterator itr = list.iterator();
        while (itr.hasNext()) {
            Map.Entry<K, V> m = (Map.Entry<K, V>) itr.next();
            result.put(m.getKey(), m.getValue());
        }

        return result;
    }

静态映射排序值（映射映射）{
列表