Java Map按值排序的正确姿势

时间：2025-04-03 22:07:55

 作者：明明如月学长， **** 博客专家，蚂蚁集团高级 Java 工程师，《性能优化方法论》作者、《解锁大厂思维：剖析《阿里巴巴Java开发手册》》、《再学经典：《EffectiveJava》独家解析》专栏作者。

热门文章推荐：
（1）《人工智能时代，软件工程师们将会被取代？》
（2）《超全人工智能 AI工具导航网站合集》
（3）《如何写出高质量的文章：从战略到战术》
（4）《什么？ 你还没用过 Cursor？ 智能 AI 代码生成工具 Cursor 安装和使用介绍》
（5）《我的性能方法论》
（6）《无需魔法打开即用的 AI 工具集锦》

在实际业务开发中，可能会遇到Java Map按值排序的需要。

Java Map按值排序的常见思路是：

1、 将map中的entry放到List中

2、 对List中的entry通过比较器按值排序

3 、将排序后的entry放到linkedhashmap中

Java 8利用Stream

import ;
import ;
import ;
import ;

import static ;
import static ;

public class SortTest {

    public static void main(String[] args) throws Exception {

        // 创建一个字符串为Key，数字为值的map
        Map<String, Integer> budget = new HashMap<>();
        ("clothes", 120);
        ("grocery", 150);
        ("transportation", 100);
        ("utility", 130);
        ("rent", 1150);
        ("miscellneous", 90);
        ("排序前: " + budget);

        // 按值排序 升序
        Map<String, Integer> sorted = budget
                .entrySet()
                .stream()
                .sorted(comparingByValue())
                .collect(
                        toMap(::getKey, ::getValue, (e1, e2) -> e2,
                                LinkedHashMap::new));

        ("升序按值排序后的map: " + sorted);

        // 按值排序降序
        sorted = budget
                .entrySet()
                .stream()
                .sorted((comparingByValue()))
                .collect(
                        toMap(::getKey, ::getValue, (e1, e2) -> e2,
                                LinkedHashMap::new));

        ("降序按值排序后的map: " + sorted);
    }


}

可以封装成工具类

/**
 * Map排序工具类
 *
 * @author liuwangyanghdu@  明明如月
 */
public class MapSortUtil {
    
    private static Comparator<> comparatorByKeyAsc = ( o1,  o2) -> {
        if (() instanceof Comparable) {
            return ((Comparable) ()).compareTo(());
        }
        throw new UnsupportedOperationException("键的类型尚未实现Comparable接口");
    };


    private static Comparator<> comparatorByKeyDesc = ( o1,  o2) -> {
        if (() instanceof Comparable) {
            return ((Comparable) ()).compareTo(());
        }
        throw new UnsupportedOperationException("键的类型尚未实现Comparable接口");
    };


    private static Comparator<> comparatorByValueAsc = ( o1,  o2) -> {
        if (() instanceof Comparable) {
            return ((Comparable) ()).compareTo(());
        }
        throw new UnsupportedOperationException("值的类型尚未实现Comparable接口");
    };


    private static Comparator<> comparatorByValueDesc = ( o1,  o2) -> {
        if (() instanceof Comparable) {
            return ((Comparable) ()).compareTo(());
        }
        throw new UnsupportedOperationException("值的类型尚未实现Comparable接口");
    };

    /**
     * 按键升序排列
     */
    public static <K, V> Map<K, V> sortByKeyAsc(Map<K, V> originMap) {
        if (originMap == null) {
            return null;
        }
        return sort(originMap, comparatorByKeyAsc);
    }

    /**
     * 按键降序排列
     */
    public static <K, V> Map<K, V> sortByKeyDesc(Map<K, V> originMap) {
        if (originMap == null) {
            return null;
        }
        return sort(originMap, comparatorByKeyDesc);
    }


    /**
     * 按值升序排列
     */
    public static <K, V> Map<K, V> sortByValueAsc(Map<K, V> originMap) {
        if (originMap == null) {
            return null;
        }
        return sort(originMap, comparatorByValueAsc);
    }

    /**
     * 按值降序排列
     */
    public static <K, V> Map<K, V> sortByValueDesc(Map<K, V> originMap) {
        if (originMap == null) {
            return null;
        }
        return sort(originMap, comparatorByValueDesc);
    }

    private static <K, V> Map<K, V> sort(Map<K, V> originMap, Comparator<> comparator) {
        return ()
                .stream()
                .sorted(comparator)
                .collect(
                        (::getKey, ::getValue, (e1, e2) -> e2,
                                LinkedHashMap::new));
    }

}

测试类

package ;

import ;
import ;
import ;

import ;
import ;


/**
 * Map排序工具类
 *
 * @author liuwangyanghdu@  明明如月
 */
@TestInstance(.PER_CLASS)
class MapSortUtilTest {
    // 创建一个字符串为Key，数字为值的map
    Map<String, Integer> budget = new HashMap<>();

    @BeforeAll
    public void init() {
        ("clothes", 120);
        ("grocery", 150);
        ("transportation", 100);
        ("utility", 130);
        ("rent", 1150);
        ("miscellneous", 90);
        ("排序前: " + budget);
    }

    @Test
    void sortByKeyAsc() {
        ("按键升序" + (budget));
    }

    @Test
    void sortByKeyDesc() {
        ("按键降序" + (budget));
    }

    @Test
    void sortByValueAsc() {
        ("按值升序" + (budget));
    }

    @Test
    void sortByValueDesc() {
        ("按值降序" + (budget));
    }
}

Java 7版本


import .*; 
import .*; 

public class GFG { 

	//  hashmap按值排序
	public static HashMap<String, Integer> sortByValue(HashMap<String, Integer> hm) 
	{ 
		// HashMap的entry放到List中
		List<<String, Integer> > list = 
			new LinkedList<<String, Integer> >(()); 

		//  对List按entry的value排序
		(list, new Comparator<<String, Integer> >() { 
			public int compare(<String, Integer> o1, 
							<String, Integer> o2) 
			{ 
				return (()).compareTo(()); 
			} 
		}); 
		
		// 将排序后的元素放到LinkedHashMap中
		HashMap<String, Integer> temp = new LinkedHashMap<String, Integer>(); 
		for (<String, Integer> aa : list) { 
			((), ()); 
		} 
		return temp; 
	} 

	
	public static void main(String[] args) 
	{ 

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

		// 填充测试数据
		("Math", 98); 
		("Data Structure", 85); 
		("Database", 91); 
		("Java", 95); 
		("Operating System", 79); 
		("Networking", 80); 
		Map<String, Integer> hm1 = sortByValue(hm); 

		// 打印按值排序后的数据
		for (<String, Integer> en : ()) { 
			("Key = " + () + 
						", Value = " + ()); 
		} 
	} 
}

参考文章：

1、 Java 8 – Sorting HashMap by values in ascending and descending order

2、 Sort a Map by values

3、Sorting a Hashmap according to values

如果文章对你有帮助，欢迎点赞，关注，你的鼓励是我创作的最大动力！！

相关文章