map对值排序

本文介绍了一种使用Java实现的Map排序方法,通过将原始Map转换为ArrayList并利用Collections.sort方法结合自定义Comparator来完成排序。文章提供了针对不同数据类型(如Integer、Double和String)的Map排序示例,并对比了HashMap、TreeMap、LinkedHashMap和IdentityHashMap的特点。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

/**
 * 
 */
package com.fritt.planmanage.util;


import java.util.ArrayList;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;


import edu.emory.mathcs.backport.java.util.Collections;


/**
 * @author lf
 * 
 */
public class SortMap {


public  static Map<String, Integer> sortMap(Map<String, Integer> oldMap) {
ArrayList<Map.Entry<String, Integer>> list = 
new ArrayList<Map.Entry<String, Integer>>(oldMap.entrySet());
Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {


@Override
public int compare(Entry<java.lang.String, Integer> arg0,
Entry<java.lang.String, Integer> arg1) {
return arg1.getValue() - arg0.getValue();           //对map值进行降序排序
}
});
Map<String, Integer> newMap = new LinkedHashMap<String, Integer>();
for (int i = 0; i < list.size(); i++) {
newMap.put(list.get(i).getKey(), list.get(i).getValue());
}
return newMap;
}

public  static Map<String, Double> sortMap_Double(Map<String, Double> oldMap) {
ArrayList<Map.Entry<String, Double>> list = 
new ArrayList<Map.Entry<String, Double>>(oldMap.entrySet());
Collections.sort(list, new Comparator<Map.Entry<String, Double>>() {


@Override
public int compare(Entry<java.lang.String, Double> arg0,
Entry<java.lang.String, Double> arg1) {

return arg1.getValue().compareTo(arg0.getValue());
}
});
Map<String, Double> newMap = new LinkedHashMap<String, Double>();
for (int i = 0; i <list.size(); i++) {
newMap.put(list.get(i).getKey(), list.get(i).getValue());
}
return newMap;
}

public  static Map<String, String> sortMap_String(Map<String, String> oldMap) {
ArrayList<Map.Entry<String, String>> list = 
new ArrayList<Map.Entry<String, String>>(oldMap.entrySet());
Collections.sort(list, new Comparator<Map.Entry<String, String>>() {


@Override
public int compare(Entry<String, String> arg0,Entry<String,String> arg1) {
return arg0.getValue().compareTo(arg1.getValue());      //升序排序
}
});
Map<String, String> newMap = new LinkedHashMap<String, String>();
for (int i = list.size()-1; i >=0; i--) {                        //从后向前导入,相当于降序
newMap.put(list.get(i).getKey(), list.get(i).getValue());
}
return newMap;
}

}


HashMap:输入的<key,value>对是乱序插入,比较快,key不允许重复

TreeMap:有序,对输入的<key,value>进行排序,默认将按照key值进行升序排序,key不允许重复,若重复,后面的覆盖前面的

LinkedHashMap:保留插入的顺序,如果需要输出的顺序和输入时的相同,那么就选用LinkedHashMap。

IdentityHashMap:key允许重复,只要两个key的地址不相等即可。


  1. public class Test {  
  2.       
  3.     public static void main(String[] args) {  
  4.           
  5.         //不指定排序器  
  6.         TreeMap<String, String> treeMap1 = new TreeMap<String, String>();  
  7.         treeMap1.put("2""1");  
  8.         treeMap1.put("b""1");  
  9.         treeMap1.put("1""1");  
  10.         treeMap1.put("a""1");  
  11.         System.out.println("treeMap1="+treeMap1);  
  12.   
  13.         //指定排序器  
  14.         TreeMap<String, String> treeMap2 = new TreeMap<String, String>(new Comparator<String>(){  
  15.   
  16.             /* 
  17.              * int compare(Object o1, Object o2) 返回一个基本类型的整型, 
  18.              * 返回负数表示:o1 小于o2, 
  19.              * 返回0 表示:o1和o2相等, 
  20.              * 返回正数表示:o1大于o2。 
  21.              */  
  22.             public int compare(String o1, String o2) {  
  23.               
  24.                 //指定排序器按照降序排列  
  25.                 return o2.compareTo(o1);  
  26.             }     
  27.         });  
  28.         treeMap2.put("2""1");  
  29.         treeMap2.put("b""1");  
  30.         treeMap2.put("1""1");  
  31.         treeMap2.put("a""1");  
  32.         System.out.println("treeMap2="+treeMap2);  
  33.     }  
  34. }  

 

执行输出结果:

Java代码   收藏代码
  1. treeMap1={1=12=1, a=1, b=1}  
  2. treeMap2={b=1, a=12=11=1}  


### 对Map排序的方法及实现 在编程中,对 `Map` 按进行排序是一种常见的需求。Java 提供了多种方法来实现这一功能。以下将详细介绍如何使用 Java 实现对 `Map` 按排序的代码示例[^2]。 首先,可以将 `Map` 转换为一个包含所有键对的列表,然后对该列表按照进行排序。具体实现如下: ```java import java.util.*; public class MapSortByValueExample { public static void main(String[] args) { // 创建一个HashMap并添加一些数据 Map<String, Integer> map = new HashMap<>(); map.put("Banana", 2); map.put("Apple", 1); map.put("Carrot", 3); // 将Map转换为List<Map.Entry> List<Map.Entry<String, Integer>> list = new ArrayList<>(map.entrySet()); // 使用Collections.sort()对List进行排序 list.sort(Map.Entry.comparingByValue()); // 输出排序后的结果 for (Map.Entry<String, Integer> entry : list) { System.out.println(entry.getKey() + ": " + entry.getValue()); } } } ``` 上述代码中,`Map.Entry.comparingByValue()` 是 JDK 1.8 引入的函数式编程特性,用于指定按照进行排序的规则[^2]。如果需要倒序排列,可以使用 `reversed()` 方法: ```java list.sort(Collections.reverseOrder(Map.Entry.comparingByValue())); ``` 此外,还可以通过自定义比较器实现更复杂的排序逻辑。例如,以下代码展示了如何根据的大小进行降序排序: ```java list.sort(new Comparator<Map.Entry<String, Integer>>() { @Override public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) { return o2.getValue().compareTo(o1.getValue()); } }); ``` 对于更复杂的需求,如同时考虑键和排序规则,可以通过扩展自定义比较器来实现。 ### 注意事项 - 上述代码适用于 JDK 1.8 及以上版本。 - 如果需要保留原始 `Map` 的结构,建议将排序后的结果存储在一个新的 `Map` 或其他集合中。 - 在某些情况下,可能需要处理相同的情况,此时可以结合键的自然顺序或其他规则进一步排序
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值