精华内容
下载资源
问答
  • 2019-06-04 05:40:51

    前言:

    随着Java 8 的

    Stream
    之后推出后可以很优雅实现Map的排序。

    示例:

    final Map<String, Integer> wordCounts = new HashMap<>();
    wordCounts.put("USA", 100);
    wordCounts.put("jobs", 200);
    wordCounts.put("software", 50);
    wordCounts.put("technology", 70);
    wordCounts.put("opportunity", 200);
    
    //{USA=100, software=50, jobs=200, opportunity=200, technology=70}复制代码

    按升序对值进行排序,使用

    LinkedHashMap
    存储排序结果来保留结果映射中元素的顺序

    1、正向 
    final Map<String, Integer> sortedByCount = wordCounts.entrySet()
                    .stream()
                    .sorted(Map.Entry.comparingByValue())
                    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
    
    //{software=50, technology=70, USA=100, jobs=200, opportunity=200}
    
    2、反向 reversed
    final Map<String, Integer> sortedByCount1 = wordCounts.entrySet()
            .stream()
            .sorted((Map.Entry.<String, Integer>comparingByValue().reversed()))
            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
    
    //{jobs=200, opportunity=200, USA=100, technology=70, software=50}复制代码

    推荐

    sorted()
    方法将
    Comparator
    作为参数使用任何类型的值对映射进行排序。上面的排序可以用
    Comparator
    写成:

    //正向 
      final Map<String, Integer> sortedByCount3 = wordCounts.entrySet()
            .stream()
            .sorted((e1, e2) -> e1.getValue().compareTo(e2.getValue()))
            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
    //{software=50, technology=70, USA=100, jobs=200, opportunity=200}
    
    
    //反向 == reversed()
    final Map<String, Integer> sortedByCount2 = wordCounts.entrySet()
                    .stream()
                    .sorted((e1, e2) -> e2.getValue().compareTo(e1.getValue()))
                    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
    
    //{jobs=200, opportunity=200, USA=100, technology=70, software=50}
    复制代码


    转载于:https://juejin.im/post/5cf6044cf265da1bb13f1db1

    更多相关内容
  • 主要介绍了java如何对map进行排序,java map集合的使用详解,大家可以参考使用
  • java中对Map进行排序的方法

    千次阅读 2019-10-05 23:44:09
    java中经常排序,但是自己Map的排序方法一直不是很清楚,特此记录。 Map作为键值的存储...在讲解Map排序之前,我们先来稍微了解下map。map是键值的集合接口,它的实现类主要包括:HashMap,TreeMap,Hashtable...

    java中经常排序,但是自己对Map的排序方法一直不是很清楚,特此记录。
    Map作为键值对的存储工具,基本的概念介绍网上都有,自己参考如下博客:

    https://www.cnblogs.com/chenssy/p/3264214.html

    简单介绍Map
    在讲解Map排序之前,我们先来稍微了解下map。map是键值对的集合接口,它的实现类主要包括:HashMap,TreeMap,Hashtable以及LinkedHashMap等。其中这四者的区别如下(简单介绍)一般使用HashMap和TreeMap

    • HashMap:我们最常用的Map,它根据key的HashCode 值来存储数据,根据key可以直接获取它的Value,同时它具有很快的访问速度。HashMap最多只允许一条记录的key值为Null(多条会覆盖);允许多条记录的Value为 Null。非同步的。
    • TreeMap: 能够把它保存的记录根据key排序,默认是按升序排序,也可以指定排序的比较器,当用Iterator 遍历TreeMap时,得到的记录是排过序的。TreeMap不允许key的值为null。非同步的。
    • Hashtable: 与 HashMap类似,不同的是:key和value的值均不允许为null;它支持线程的同步,即任一时刻只有一个线程能写Hashtable,因此也导致了Hashtale在写入时会比较慢。
    • LinkedHashMap: 保存了记录的插入顺序,在用Iterator遍历LinkedHashMap时,先得到的记录肯定是先插入的.在遍历的时候会比HashMap慢。key和value均允许为空,非同步的。

    本文正文下面式排序方式的介绍:

    Map的排序方式一 直接使用TreeMap进行排序

    public class test {
        public static void main(String[] args) {
            Map<String, String> map = new TreeMap<>();
            map.put("a", "I'am a");
            map.put("c", "I'am c");
            map.put("d", "I'am d");
            map.put("b", "I'am b");
            for (Map.Entry<String, String> entry : map.entrySet()) {
                System.out.println(entry.getKey() + " " + entry.getValue());
            }
        }
    }
    

    输出的结果如下:

    a I’am a
    b I’am b
    c I’am c
    d I’am d

    但是上面的排序默认是按照Key值进行排序的,并且按照的是默认的升序排序,如果我们想改变默认的排序方式,即按照我们自己的比较方式排序,我们就需要实现自己的比较器,实现方式如下(下面的这种实现方式只能根据key值进行排序):
    下面的代码实现了根据key值进行降序排序

    public class test {
        public static void main(String[] args) {
            Map<Integer, String> map = new TreeMap<>(new Comparator<Integer>() {
                @Override
                public int compare(Integer o1, Integer o2) {
                    return o2 - o1;
                }
            });
            // 上面的Map可也以写成lambda表达式的形式    Map<Integer, String> map = //new TreeMap<>((o1, o2) -> o2 - o1);
    
            map.put(3, "I'am 3");
            map.put(0, "I'am 0");
            map.put(2, "I'am 2");
            map.put(1, "I'am 1");
            for (Map.Entry<Integer, String> entry : map.entrySet()) {
                System.out.println(entry.getKey() + " " + entry.getValue());
            }
        }
    }
    

    输出:
    3 I’am 3
    2 I’am 2
    1 I’am 1
    0 I’am 0

    以上的排序方法都是根据Key值进行排序,如果我们想根据value进行排序或者根据value和key进行排序,我们可以使用如下的方法

    首先将map中的值转存到list中,然后对List进行排序,之后将list排序结果取出,再存储到LinkedHashMap中

    public class test {
        public static void main(String[] args) {
            Map<String, String> map = new HashMap<>();
            map.put("I am d", "aaad");
            map.put("I am c", "cs");
            map.put("I am b", "baa");
            map.put("I am a", "a");
            List<Map.Entry<String, String>> list = new LinkedList<>(map.entrySet());
    
    
            // 下面的也可以写成lambda表达式这种形式
            // Collections.sort(list, (o1, o2) -> o2.getValue().compareTo(o1.getValue()));
            Collections.sort(list, new Comparator<Map.Entry<String, String>>() {
                @Override
                public int compare(Map.Entry<String, String> o1, Map.Entry<String, String> o2) {
                    return o2.getValue().compareTo(o1.getValue()); // 这里改为根据value值进降序排序,这里也可以改成根据key和value进行排序
                }
            });
            Map<String, String> result = new LinkedHashMap<>();
            for (Map.Entry<String, String> entry : list) {
                result.put(entry.getKey(), entry.getValue());
            }
            System.out.println(result);
        }
    }
    
    

    输出结果:
    {I am c=cs, I am b=baa, I am d=aaad, I am a=a}
    这种自己平常不太使用,自己通常使用stream进行排序。

    Map排序方法二:使用stream进行排序

            Map<Integer, String> map = new HashMap<>();
            map.put(100, "I'am a");
            map.put(99, "I'am c");
            map.put(2, "I'am d");
            map.put(33, "I'am b");
            // 按照value进行倒排,如果要根据key进行排序的话使用Map.Entry.comparingByKey()
            map.entrySet().stream().sorted(Collections.reverseOrder(Map.Entry.comparingByValue()))
                    .forEach(System.out::println);
            // 根据value进行正序排序,根据key进行排序的话使用comparingByKey()
            map.entrySet().stream().sorted(Map.Entry.comparingByValue()).forEach(System.out::println);
    
            // 如果要将排序的结果返回的话,我们可以使用下面的方法(注意:要使用LinkedHashMap进行保存,linkedHashMap可以保存插入顺序)
            Map<Integer, String> resultMap1 = map.entrySet().stream().sorted(Map.Entry.comparingByValue()).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (s, s2) -> s,
                    LinkedHashMap::new));
    
            // 下面的这种写法同上面的写法,只不过是将简写展开了,这样更易于理解
            Map<Integer, String> resultMap = map.entrySet().stream().sorted(Map.Entry.comparingByValue()).collect(Collectors.toMap(new Function<Map.Entry<Integer, String>, Integer>() {
                @Override
                public Integer apply(Map.Entry<Integer, String> integerStringEntry) {
                    return integerStringEntry.getKey();
                }
            }, new Function<Map.Entry<Integer, String>, String>() {
                @Override
                public String apply(Map.Entry<Integer, String> integerStringEntry) {
                    return integerStringEntry.getValue();
                }
            }, new BinaryOperator<String>() {
                @Override
                public String apply(String s, String s2) {
                    return s;
                }
            }, new Supplier<Map<Integer, String>>() {
                @Override
                public Map<Integer, String> get() {
                    return new LinkedHashMap<>();
                }
            }));
    
            // 同样如果需要将排序的将结果作为Map进行返回我们还可以使用下面的方法,但是不推荐这种方式(effectivejava 178页中说:foreach操作应该只用于报告stream计算的结果,而不是执行计算)
            Map<Integer, String> result2 = new LinkedHashMap<>();
            map.entrySet().stream().sorted(Map.Entry.comparingByValue()).forEach(new Consumer<Map.Entry<Integer, String>>() {
                @Override
                public void accept(Map.Entry<Integer, String> integerStringEntry) {
                    result2.put(integerStringEntry.getKey(), integerStringEntry.getValue());
                }
            });
    

    https://www.jianshu.com/p/d20d2afbf87e

    https://www.cnblogs.com/zimug/p/11781375.html
    https://blog.csdn.net/hao134838/article/details/80780622

    展开全文
  • 如何对map进行排序

    万次阅读 多人点赞 2018-11-22 16:05:40
    Map介绍 常用的Map有HashMap,TreeMap,LinkedHashMap HashMap:最常用的Map,根据key的HashCode值来存储数据,根据key可以直接获取它的Value,具有很快...TreeMap: 根据key排序,默认是按升序排序,也可以指定排序...

    Map介绍

    常用的Map有HashMap,TreeMap,LinkedHashMap

    HashMap:最常用的Map,根据key的HashCode值来存储数据,根据key可以直接获取它的Value,具有很快的访问速度。HashMap最多只允许一条记录的key值为null(多条会覆盖);允许多条记录的Value为null。非线程安全

    TreeMap: 根据key排序,默认是按升序排序,也可以指定排序的比较器,遍历TreeMap时,得到的记录是排过序的。TreeMap不允许key的值为null。非线程安全

    LinkedHashMap: 插入顺序,遍历LinkedHashMap时,先得到的记录肯定是先插入的。继承HashMap,非线程安全

    TreeMap排序

    TreeMap只能根据key进行排序,TreeMap本身是个二叉树,元素的顺序是由key的值决定的

    TreeMap内部默认有个Comparator,在new的时候可以覆盖默认的Comparator定义自己的排序规则,不过还是只能根据key进行排序

    private static void sortTreeMap(){
        Map<String,String> map =new TreeMap<>((k1,k2)->{
            return k1.compareTo(k2);
        });
        map.put("a","2");
        map.put("c","5");
        map.put("d","6");
        map.put("b","1");
        map.forEach((k,v)->{
            System.out.println(k+":"+v);
        });
    }
    

    输出结果

    a:2
    b:1
    c:5
    d:6
    

    HashMap排序

    HashMap本身是没有顺序的,不能直接对其进行排序

    要排序,只能先转成list,然后对list排序后,再转成LinkedHasHMap

    这样做排序,完全由自己定义,既可以对key排序,也可以对value排序

    private static void sortMapValue(){
        Map<String,String> map =new HashMap<>();
        map.put("a","2");
        map.put("c","5");
        map.put("d","6");
        map.put("b","1");
        List<Map.Entry<String,String>> lstEntry=new ArrayList<>(map.entrySet());
        Collections.sort(lstEntry,((o1, o2) -> {
            return o1.getValue().compareTo(o2.getValue());
        }));
        lstEntry.forEach(o->{
            System.out.println(o.getKey()+":"+o.getValue());
        });
    
        //如果一定要返回一个map,就new一个LinkedHashMap,将list中所有值依次put进去就可以
        /*LinkedHashMap<String,String> linkedHashMap=new LinkedHashMap<>();
        lstEntry.forEach(o->{
            linkedHashMap.put(o.getKey(),o.getValue());
        });*/
    
    }
    

    输出结果

    b:1
    a:2
    c:5
    d:6
    
    展开全文
  • 使用lambda对map进行排序

    千次阅读 2018-10-29 11:19:06
    最近在学习lambda表达式,记录... Map&lt;String, User&gt; map = new HashMap&lt;&gt;(); map.put("1", new User("zhangsan", 17)); map.put("2", new User(...

    最近在学习lambda表达式,记录一下

    public static void main(String[] args) {
            Map<String, User> map = new HashMap<>();
            map.put("1", new User("zhangsan", 17));
            map.put("2", new User("lisi", 10));
            map.put("3", new User("wangwu", 20));
            map.put("4", new User("zhaoliu", 19));
            // 排序前
            map.forEach((key, value) -> System.out.println("key: " + key + ", value:" + value));
            map = map.entrySet().stream()
                    .sorted(Map.Entry.comparingByValue(comparingInt(User::getAge)))
                    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue,
                            (oldValue, newValue) -> oldValue, LinkedHashMap::new));
            // 排序后
            map.forEach((key, value) -> System.out.println("key: " + key + ", value:" + value));
    }
    

    User类

    @Data
    public class User{
        private String name;
        private int age;
    }
    

    排序方法

    public static <T> Comparator<T> comparingInt(ToIntFunction<? super T> keyExtractor) {
            Objects.requireNonNull(keyExtractor);
            return (Comparator<T> & Serializable)
                    (c1, c2) -> Integer.compare(keyExtractor.applyAsInt(c1), keyExtractor.applyAsInt(c2));
        }
    
    
    展开全文
  • c++对map进行排序

    千次阅读 2017-12-30 20:43:02
    (25)需要用到价格进行排序,但是排序后要用到价格对应的总售价。因而可以考虑用关联容器进行求解,map是比较合适这题的数据结构。  map是用来存放键值的数据结构,可以很方便快速的根据key查到相应的value...
  • 对Map的key和value进行排序
  • java如何对Map进行排序

    千次阅读 2021-09-20 15:54:19
    Map排序(按key排序,按value排序) 主要分两种,按键排序、按值排序。 而且,按key排序主要用于TreeMap,而按value排序则对于Map的子类们都适用。 一、按键排序 按Key排序主要用于TreeMap,可以实现按照Key值的大小...
  • 今天小编就为大家分享一篇Java中list map根据map某个key值进行排序的方法,具有很好的参考价值,希望大家有所帮助。一起跟随小编过来看看吧
  • 但是,无论实际中使用哪种实现,我们在编程过程中常常会遇到诸如根据Key或Value对Map进行排序、保持Map插入顺序等问题,本文特别针对以上几个问题给出了具体解法,并分享华为一道与我们主题极为相关的笔试题。
  • java对Map 进行排序(按字母)

    千次阅读 2020-07-11 14:41:51
    public static void main(String[] args) { Map<String, String> map = new TreeMap<String, String>( new Comparator<String>() { public int compare(String obj1, String obj2) { ...
  • java根据key或value对Map进行排序

    千次阅读 2021-04-22 17:58:18
    根据key排序 java.util包下的TreeMap可以满足此类需求,直接调用TreeMap的构造函数传入我们自己定义的比较器即可 public static Map<String, String> sortMapByKey(Map<String, String> map) { if (map...
  • 对map集合进行排序的方法

    万次阅读 2019-08-22 21:06:14
    在做统计时需要X轴的月份按照时间的先后... 在讲解Map排序之前,我们先来稍微了解下map。map是键值的集合接口,它的实现类主要包括:HashMap,TreeMap,Hashtable以及LinkedHashMap等。其中这四者的区别如下(简...
  • golang对map排序

    千次阅读 2020-06-12 17:38:03
    golang中map元素是随机无序的,所以在对map range遍历的时候也是随机的,不像php中是按顺序。所以如果想按顺序取map中的值,可以采用以下方式: import ( "fmt" "sort" ) func main() { m := make(map[int]...
  • java对Map进行排序(根据key和value)

    千次阅读 2018-09-20 09:46:26
    根据key排序 java.util包下的TreeMap可以满足此类需求,直接调用TreeMap的构造函数传入我们自己定义的比较器即可 public static Map&lt;String, String&gt; sortMapByKey(Map&lt;String, String&gt...
  • 如何对Map集合进行自定义排序

    千次阅读 2020-08-21 10:18:31
    二、如果你想自定义Map排序的话,你需要借助Comparator的帮助 1.所有的Map集合都是用的方式 Map<String,Integer> map = new HashMap<>(); map.put("key1",1); map.put("key2",2); map.put("key3",3); ...
  • 对map集合进行排序

    千次阅读 2016-06-19 16:33:34
    对map集合进行排序的时候,我们知道map中是按照key-value键值来存储数据的。那么排序的时候,就会有两种规则,第一种是按照key来排序,第二种是按照value来排序。首先来说下第一种情况,按照key来排序: //按key...
  • lambda表达式List<Map进行排序

    千次阅读 2021-02-26 11:23:39
    这种对象的数据排序可以直接用(User::getName())这种方法,如果是map呢? 方法1:写一个get方法,然后调用 方法2:lambda表达式匿名函数实现 public class StreamMap3 { public static void main(String[] ...
  • java如何对map进行排序详解

    万次阅读 2016-06-25 22:49:35
    在讲解Map排序之前,我们先来稍微了解下map。map是键值的集合接口,它的实现类主要包括:HashMap,TreeMap,Hashtable以及LinkedHashMap等。其中这四者的区别如下(简单介绍): HashMap:我们最常用的Map,它...
  • 前端JS对Map类型数据进行排序

    千次阅读 2020-05-26 15:56:21
    前端JS对Map类型数据进行排序 今天接到一个需求,按照日期数据进行倒序排序,过程中遇到一些问题,记录一下,返回数据类型如下。 var mapList = { 20200312:[ { 'key1':"000", 'key2':"111", },{...
  • 下面小编就为大家带来一篇Java Map 按key排序和按Value排序的实现方法。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • C++的map排序

    千次阅读 2022-03-20 15:52:33
    map排序默认按照key从小到大进行排序,但有以下几点需要注意: 1按照key从大到小进行排序。 2key的第1个元素是结构体。 3想按value(第二个元素)排序。 二让map中的元素按照key从大到小排序 1代码 #include <...
  • 下面小编就为大家带来一篇浅谈Java之Map 按值排序 (Map sort by value)。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 主要介绍了java8 stream 操作map根据key或者value排序的实现,文中通过示例代码介绍的非常详细,大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 460,591
精华内容 184,236
关键字:

怎么对map进行排序