精华内容
下载资源
问答
  • map集合排序

    千次阅读 2017-08-04 12:15:13
    百度了一下,膜拜了一下大佬的博客 map集合排序 但是感觉有些繁琐,因为比较菜,对Comparator比较器不熟悉,就自己想了一种易于理解办法。 场景是这样的,一个Map中,泛型为,现在要按照value从大到小对这个集合...

    写东西时遇到一个问题,要将HashMap按照value的值来进行排序。


    百度了一下,膜拜了一下大佬的博客 map集合排序


    但是感觉有些繁琐,因为比较菜,对Comparator比较器不熟悉,就自己想了一种易于理解办法。


    场景是这样的,一个Map中,泛型为<String,Double>,现在要按照value从大到小对这个集合排序,而且value值可能有相同的,所以


    没办法将它反着放进另外一个Map中,因为Map中key不能相同。


    思路是:

    建立一个二维数组,行数为2,列数为value的个数,即map.size()。遍历集合,将每一个value依次放入第一行,将每一个key依次放入第二行与之对应。这样就形成了一种对应关系,然后对第一行中的value进行排序,当要移动value时,把与之对应的key也跟着移动即可。

    代码:

    @org.junit.Test
    	public void test() throws IOException{
    		Map<String,Double> map=new LinkedHashMap<String,Double>();
    		map.put("101", 1.1);
    		map.put("103", 0.1);
    		map.put("104", 2.1);
    		map.put("105", 4.1);
    		map.put("102", 3.1);
    		
    		Double sort[][]=new Double[2][map.size()];
    		int n=0;
    		for(Entry<String,Double> e:map.entrySet()){//将value、key依次对应存入数组
    			sort[0][n]=e.getValue();
    			sort[1][n++]=Double.valueOf(e.getKey());
    		}
    		for(int i=0;i<map.size()-1;i++){//这里采用冒泡排序 复杂度取决于你用的排序方法
    			for(int j=i+1;j<map.size();j++){
    				if(sort[0][i]<sort[0][j]){
    					double t;
    					//交换value
    					t=sort[0][i];
    					sort[0][i]=sort[0][j];
    					sort[0][j]=t;
    					//交换key
    					t=sort[1][i];
    					sort[1][i]=sort[1][j];
    					sort[1][j]=t;
    				}
    			}
    		}
    		//也可以将结果再存入集合们这里直接输出
    		System.out.println("排序后:");
    		for(int i=0;i<2;i++){
    			for(int j=0;j<map.size();j++){
    				if(i!=1){
    					System.out.print(sort[i][j]+"\t");
    				}else{
    					System.out.print(String.valueOf(sort[i][j])+"\t");
    				}
    			}
    			System.out.println();
    		}
    	}

    结果:




    展开全文
  • java map 集合 排序

    2009-07-29 20:27:11
    这里有几个很经典的Java map 集合排序的例子,大家可以试试
  • Map集合排序——根据value对key进行排序 在流水的业务中,码出最优雅的代码。 描述:有若干个键值对格式的json字符串,根据其中的value进排序,取出其中的排位靠前的一半以上的key值,json数据为:{“1.B.1.f”...

    Map集合排序——根据value对key进行排序

    在流水的业务中,码出最优雅的代码。
    

    描述:有若干个键值对格式的json字符串,根据其中的value进排序,取出其中的排位靠前的一半以上的key值,json数据为:{“1.B.1.f”:”1.8”,”1.B.1.e”:”2.5”,”1.B.1.b”:”3.0”,”1.B.1.d”:”3.0”,”1.B.1.a”:”3.5”,”1.B.1.c”:”2.3”},这是业务上的一个需求,于是针对这个需求就有了对Map的排序一系列探索


    前言:对于json转Map本篇就不介绍,直接从对Map<String, Integer>的排序开始,其他类型可自行替换

    在JDK8 以前,一般都是这样写:

        public static void main(String[] args) {
            //这里自定义一个需要排序的map集合
            Map<String, Integer> map = new HashMap<String, Integer>();
            map.put("1.B.1.c", 45);
            map.put("1.B.1.d", 65);
            map.put("1.B.1.a", 12);
            map.put("1.B.1.b", 15);
            map.put("1.B.1.e", 78);
            int size = map.size();
            // 通过map.entrySet()将map转换为"1.B.1.e=78"形式的list集合
            List<Map.Entry<String, Integer>> list = new ArrayList<Map.Entry<String, Integer>>(size);
            list.addAll(map.entrySet());
            // 通过Collections.sort()排序
            Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {
                public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
                    // compareTo方法 (x < y) ? -1 : ((x == y) ? 0 : 1)
                    return o1.getValue().compareTo(o2.getValue());
                };
            });
            for (Entry<String, Integer> entry : list){
                // 得到排序后的键值
                System.out.println(entry.getKey());
            }
        }

    有时候我们会想,把这个方法提炼出来,放在一个工具类中,如是我们将会这样做:

        public static List<String> sortMapByValue(Map<String, Integer> map){  
            int size = map.size();  
            //通过map.entrySet()将map转换为"1.B.1.e=78"形式的list集合
            List<Map.Entry<String, Integer>> list = new ArrayList<Map.Entry<String, Integer>>(size);
            list.addAll(map.entrySet());
            //通过Collections.sort()排序
            Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {
                public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
                    // compareTo方法 (x < y) ? -1 : ((x == y) ? 0 : 1)
                    // 倒序:o2.getValue().compareTo(o1.getValue())
                    // 顺序:o1.getValue().compareTo(o2.getValue())
                    return o2.getValue().compareTo(o1.getValue());
                };
            }); 
            List<String> keys = new ArrayList<String>(size);  
            for (Entry<String, Integer> entry : list){
                // 得到排序后的键值
                keys.add(entry.getKey());
            }
            return keys;      
        }  
        public static void main(String[] args) {
            //这里自定义一个需要排序的map集合
            Map<String, Integer> map = new HashMap<String, Integer>();
            map.put("1.B.1.a", 45);
            map.put("1.B.1.e", 65);
            map.put("1.B.1.c", 12);
            map.put("1.B.1.b", 15);
            map.put("1.B.1.d", 78);
            List<String> keys = sortMapByValue(map);
            for (String key : keys){
                System.out.println(key);
            }
        }

    看起来好像有点复杂,而且实现Comparator接口的比较器好像可以抽离出来,其他地方也可以复用,于是:

        public static List<String> sortMapByValue(Map<String, Integer> map) {
            int size = map.size();
            //通过map.entrySet()将map转换为"1.B.1.e=78"形式的list集合
            List<Map.Entry<String, Integer>> list = new ArrayList<Map.Entry<String, Integer>>(size);
            list.addAll(map.entrySet());
            //通过Collections.sort()排序
            Collections.sort(list, new ValueComparator());
            List<String> keys = new ArrayList<String>(size);
            for (Entry<String, Integer> entry : list){
                // 得到排序后的键值
                keys.add(entry.getKey());
            }
            return keys;
        }
    
        private static class ValueComparator implements Comparator<Map.Entry<String, Integer>> {
            public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
                // compareTo方法 (x < y) ? -1 : ((x == y) ? 0 : 1)
                // 倒序:o2.getValue().compareTo(o1.getValue()),顺序:o1.getValue().compareTo(o2.getValue())
                return o2.getValue().compareTo(o1.getValue());
            }
        }
    
        public static void main(String[] args) {
            //这里自定义一个需要排序的map集合
            Map<String, Integer> map = new HashMap<String, Integer>();
            map.put("1.B.1.a", 45);
            map.put("1.B.1.e", 65);
            map.put("1.B.1.c", 12);
            map.put("1.B.1.b", 15);
            map.put("1.B.1.d", 78);
            List<String> keys = sortMapByValue(map);
            for (String key : keys){
                System.out.println(key);
            }
        }

    好像这样看起来简洁多了,而且还多了一个可复用的东西,但是,这样在JDK1.8中还远远不够。

    在JDK1.8中是这样写的

        public static List<String> sortMapByValue(Map<String, Integer> map) {
            int size = map.size();
            //通过map.entrySet()将map转换为"1.B.1.e=78"形式的list集合
            List<Map.Entry<String, Integer>> list = new ArrayList<Map.Entry<String, Integer>>(size);
            list.addAll(map.entrySet());
            List<String> keys = list.stream()
                    .sorted(Comparator.comparing(Map.Entry<String, Integer>::getValue).reversed())
                    .map(Map.Entry<String, Integer>::getKey)
                    .collect(Collectors.toList());
            return keys;
        }
    
        public static void main(String[] args) {
            //这里自定义一个需要排序的map集合
            Map<String, Integer> map = new HashMap<String, Integer>();
            map.put("1.B.1.a", 45);
            map.put("1.B.1.e", 65);
            map.put("1.B.1.c", 12);
            map.put("1.B.1.b", 15);
            map.put("1.B.1.d", 78);
            List<String> keys = sortMapByValue(map);
            keys.forEach(System.out::println);
        }
    

    惊不惊喜,意不意外。

    在JDK 1.8中新增了函数式编程,对上述代码的解释为:
    1、先将list集合转换为流,即:list.stream(),值得注意的是:在stream()中所做的任何操作都不会影响到原集合;
    2、sorted() 方法:对list集合进行排序,具体见下一篇专门针对List排序的介绍;
    3、Comparator.comparing(Map.Entry<String, Integer>::getValue):顾名思义,就是此处的比较规则,Map.Entry中有getKey(),getValue()等方法,通过改变取值,就可以改变排序对象,而默认排序为自然排序,reversed():该方法将 其改变为倒序;
    4、map(Map.Entry<String, Integer>::getKey):此处将Entry<String, Integer>中的key单独抽离出来;
    5、collect(Collectors.toList()):告诉程序返回的是一个List集合;


    全文到此,对JDK1.8中的新特性还不熟悉的仔仔们,可以去看一些相关文档,预计下一篇为:《List集合排序——汇总》

    展开全文
  • java8新特性:对map集合排序,根据key或者value操作排序(升序、降序) 直接上代码: package com.drew.test; import java.util.List; import java.util.Map; import com.google.common.collect.ImmutableMap...

    java8新特性:对map集合排序,根据key或者value操作排序(升序、降序)

    直接上代码:

    复制代码

    package com.drew.test;
    
    import java.util.List;
    import java.util.Map;
    
    import com.google.common.collect.ImmutableMap;
    import com.google.common.collect.Lists;
    import com.google.common.collect.Maps;
    
    /**
     * @author zero 2019/04/08
     */
    public class Java8future {
    
        public static void main(String[] args) {
            Map<String, Integer> map = ImmutableMap.of("0", 3, "1", 8, "0.29", 7, "1.67", 3);
            System.out.println("原始的map:" + map);
            System.out.println("根据map的key降序:" + sortByKey(map, true));
            System.out.println("根据map的key升序:" + sortByKey(map, false));
            System.out.println("根据map的value降序:" + sortByValue(map, true));
            System.out.println("根据map的value升序:" + sortByValue(map, false));
        }
    
        /**
         * 根据map的key排序
         * 
         * @param map 待排序的map
         * @param isDesc 是否降序,true:降序,false:升序
         * @return 排序好的map
         * @author zero 2019/04/08
         */
        public static <K extends Comparable<? super K>, V> Map<K, V> sortByKey(Map<K, V> map, boolean isDesc) {
            Map<K, V> result = Maps.newLinkedHashMap();
            if (isDesc) {
                map.entrySet().stream().sorted(Map.Entry.<K, V>comparingByKey().reversed())
                    .forEachOrdered(e -> result.put(e.getKey(), e.getValue()));
            } else {
                map.entrySet().stream().sorted(Map.Entry.<K, V>comparingByKey())
                    .forEachOrdered(e -> result.put(e.getKey(), e.getValue()));
            }
            return result;
        }
    
        /**
         * 根据map的value排序
         * 
         * @param map 待排序的map
         * @param isDesc 是否降序,true:降序,false:升序
         * @return 排序好的map
         * @author zero 2019/04/08
         */
        public static <K, V extends Comparable<? super V>> Map<K, V> sortByValue(Map<K, V> map, boolean isDesc) {
            Map<K, V> result = Maps.newLinkedHashMap();
            if (isDesc) {            
                map.entrySet().stream().sorted(Map.Entry.<K, V>comparingByValue().reversed())
                .forEach(e -> result.put(e.getKey(), e.getValue()));
            } else {            
                map.entrySet().stream().sorted(Map.Entry.<K, V>comparingByValue())
                .forEachOrdered(e -> result.put(e.getKey(), e.getValue()));
            }
            return result;
        }
    }
    展开全文
  • Java 实现Map集合排序功能

    千次阅读 2015-01-12 18:35:52
    // 初始化Map集合 List> columns = new ArrayList>(); Map c1 = new HashMap(); c1.put("sort", "8"); c1.put("title", "www.chuweibiao.com"); columns.add(c1); Map c2 = new HashMap()

    第一步:Map中新增sort临时键

    // 初始化Map集合
    List<Map<String, String>> columns = new ArrayList<Map<String, String>>();
    Map<String, String> c1 = new HashMap<String,String>();
    c1.put("sort", "8");
    c1.put("title", "www.chuweibiao.com");
    columns.add(c1);
    Map<String, String> c2 = new HashMap<String,String>();
    c2.put("sort", "5");
    c2.put("title", "www.chuweibiao.com");
    columns.add(c2);
    Map<String, String> c3 = new HashMap<String,String>();
    c3.put("sort", "13");
    c3.put("title", "www.chuweibiao.com");
    columns.add(c3);

    第二步:进行排序

    /**
     * Map类型元素集合排序
     * @param columns
     * 		Map类型元素集合
     */
    private void listSortingForMapTypeElement(List<Map<String, Object>> columns) {
    	Collections.sort(columns, new Comparator<Map<String, Object>>() {
    		public int compare(Map<String, Object> last, Map<String, Object> next) {
    			Object lastSort = last.get("sort");
    			Object nextSort = next.get("sort");
    			if (lastSort == null || nextSort == null) {
    				return 0;
    			} else {
    				return Integer.parseInt(String.valueOf(lastSort)) 
    						> Integer.parseInt(String.valueOf(nextSort)) ? 1 : 0;
    			}
    		}
    	});
    }

    第三步:移除临时键

    /**
     * 移除排序临时键
     * @param columns
     * 		Map类型元素集合
     */
    private void removeSortKey(List<Map<String, Object>> columns) {
    	for (Map<String, Object> column : columns) {
    		column.remove("sort");
    	}
    }

    谁有更好的办法请拍砖指教,O(∩_∩)O谢谢~
    展开全文
  • import java.util.List;...import java.util.Map; import com.google.common.collect.ImmutableMap; import com.google.common.collect.Lists; import com.google.common.collect.Maps; /**...
  • 主要介绍了java如何对map进行排序,java map集合的使用详解,大家可以参考使用
  • map集合进行排序

    2016-07-18 19:51:31
    今天做统计时需要对X轴的地区按照地区代码(areaCode)进行排序,由于在构建XMLData使用的map...map是键值对的集合接口,它的实现类主要包括:HashMap,TreeMap,Hashtable以及LinkedHashMap等。其中这四者的区别如下(简
  • 实现思路:将Map key,value模式转换为List key=value模式,然后利用冒泡排序进行排序 Map<Long, Double> historyBuy = new HashMap<... // 获得map集合 List<Map.Entry<Long, Double>> l...
  • 这是工具类中的代码 package com.demo.utils; import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; import java.util.Map; ... * 给map集合中的key实现字...
  • Map中元素存放是无序的 HashMap注意事项: 1,HashMap底层维护一个数组,我们向HashMap中所放置的对象实际上是存储在该数组当中; 2,当向HashMap中put一对键值时,它会根据key的hashCode值计算出一个位置,该位置...
  • map集合进行排序的方法

    万次阅读 2019-08-22 21:06:14
    在做统计时需要对X轴的月份按照时间的先后进行排序,由于在构建XMLData使用的map来进行...map是键值对的集合接口,它的实现类主要包括:HashMap,TreeMap,Hashtable以及LinkedHashMap等。其中这四者的区别如下(简...
  • map集合根据value排序

    2019-06-27 10:23:58
    map集合根据value从大到小排序 `` vgsdz // map集合根据value从大到小排序 public static List sortMapByValue(Map<String, Integer> map) { int size = map.size(); //通过map.entrySet()将map转换为"1.B.1....
  • Stream排序Map集合

    千次阅读 2019-03-11 19:45:13
    map根据value倒序排序 map.entrySet().stream().sorted(Collections.reverseOrder(Map.Entry.comparingByValue())).forEach(System.out::println); map根据key倒序排序 map.entryS...
  • Activity 间intent传递有序排序map集合 intent传递map排序
  • 简析Map及Map集合的遍历解析、排序

    千次阅读 2017-04-22 16:39:50
    简析Map及Map集合的遍历解析、排序 扯点犊子: 其实Android对Java基础的要求并不高,虽然Android是基于Java的,但是Android有更多它自己的东西。 但是对于Java基础还是需要充分的了解,这会对你的开发事半功倍,就像...
  • 1、简单介绍Map在讲解Map排序之前,我们先来稍微了解下mapmap是键值对的集合接口,它的实现类主要包括:HashMap,TreeMap,Hashtable以及LinkedHashMap。其中这四者的区别如下(简单介绍): HashMap:我们最常用...
  • map集合字母排序

    2017-04-20 11:32:34
    // 第一步:检查参数是否已经排序 Map params= new HashMap(); Map returnMap = new HashMap(); String[] keys = params.keySet().toArray(new String[0]); Arrays.sort(keys); // 第二步:把...
  • map排序.txt

    2019-08-23 10:11:15
    map集合排序方法,亲测有效,分享出来,大家看看
  • Java集合排序及java集合类详解(Collection、List、Map、Set)

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 184,061
精华内容 73,624
关键字:

map集合排序