精华内容
下载资源
问答
  • 1.根据key键给map排序public static void main(String[] args) {Map<Integer,String> map = new TreeMap<>(new Comparator<Integer>(){@Overridepublic int compare...

    1.根据key键给map排序

        public static void main(String[] args) {
            Map<Integer,String> map = new TreeMap<>(new Comparator<Integer>(){
                @Override
                public int compare(Integero1, Integer o2) {
                    return o1-o2;//按照key顺序排列,o2-o1是逆序
                }
            });
            map.put(3, "China");
            map.put(8, "America");
            map.put(2, "Canada");
            map.put(1, "Franch");
            map.put(5, "Banana");
    //map遍历
            Set<Integer> set = map.keySet();
            Iterator<Integer> iterator = set.iterator();
            while(iterator.hasNext()){
                Integer key2 = iterator.next();
                System.out.println(key2+"-------"+map.get(key2));
            }
        }


    排序结果:

    1-------Franch
    2-------Canada
    3-------China

    5-------Banana
    8-------America

    注意:标红部分的对应关系,因为key是Integer,所以,比较器的泛型和参数 都是Integer.


    2.根据value给map排序

        public static void main(String[] args) {
            TreeMap<Integer, String> map = new TreeMap<>();
            map.put(3, "China");
            map.put(8, "America");
            map.put(2, "Canada");
            map.put(1, "Franch");
            map.put(5, "Banana");
    
            ArrayList<Entry<Integer, String>> list =
                    new ArrayList<Map.Entry<Integer, String>>(map.entrySet());
    
            Collections.sort(list, new Comparator<Map.Entry<Integer, String>>() {
                @Override
                public int compare(Entry<Integer, String> o1,
                                   Entry<Integer, String> o2) {
                    return o1.getValue().compareTo(o2.getValue());//顺序
                }
            });
    
            for (Entry<Integer, String> entry : list) {
                System.out.println(entry.getKey()+"------"+entry.getValue());
            }
        }


    排序结果:

    8------America
    5------Banana
    2------Canada
    3------China
    1------Franch

    如果想要逆序,改变o1和o2的顺序即可,蓝色部分改为:

    o2.getValue().compareTo(o1.getValue())

    展开全文
  • golang对map排序

    千次阅读 2020-06-12 17:38:03
    所以如果想按顺序取map中的值,可以采用以下方式: import ( "fmt" "sort" ) func main() { m := make(map[int]string) m[1] = "a" m[2] = "c" m[0] = "b" //拿到key var keys []int for k := range m {

    golang中map元素是随机无序的,所以在对map range遍历的时候也是随机的,不像php中是按顺序。所以如果想按顺序取map中的值,可以采用以下方式:

    import (
        "fmt"
        "sort"
    )
    
    func main() {
        m := make(map[int]string)
        m[1] = "a"
        m[2] = "c"
        m[0] = "b"
    	//拿到key
        var keys []int
        for k := range m {
            keys = append(keys, k)
        }
        //对key排序
        sort.Ints(keys)
    	//根据key从m中拿元素,就是按顺序拿了
        for _, k := range keys {
            fmt.Println("Key:", k, "Value:", m[k])
        }
    }
    
    展开全文
  • JAVA map排序实现

    万次阅读 2019-06-03 14:19:14
    Map排序的方式有很多种,这里记录下自己总结的两种比较常用的方式:按键排序(sort by key), 按值排序(sort by value)。 1、按键排序 jdk内置的java.util包下的TreeMap<K,V>既可满足此类需求,向其构造...

    Map排序的方式有很多种,这里记录下自己总结的两种比较常用的方式:按键排序(sort by key), 按值排序(sort by value)。

     

    1、按键排序

    jdk内置的java.util包下的TreeMap<K,V>既可满足此类需求,向其构造方法 TreeMap(Comparator<? super K> comparator)  传入我们自定义的比较器即可实现按键排序。

     

    实现代码

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    public class MapSortDemo {

     

        public static void main(String[] args) {

     

            Map<String, String> map = new TreeMap<String, String>();

     

            map.put("KFC", "kfc");

            map.put("WNBA", "wnba");

            map.put("NBA", "nba");

            map.put("CBA", "cba");

     

            Map<String, String> resultMap = sortMapByKey(map);    //按Key进行排序

     

            for (Map.Entry<String, String> entry : resultMap.entrySet()) {

                System.out.println(entry.getKey() + " " + entry.getValue());

            }

        }

         

        /**

         * 使用 Map按key进行排序

         * @param map

         * @return

         */

        public static Map<String, String> sortMapByKey(Map<String, String> map) {

            if (map == null || map.isEmpty()) {

                return null;

            }

     

            Map<String, String> sortMap = new TreeMap<String, String>(

                    new MapKeyComparator());

     

            sortMap.putAll(map);

     

            return sortMap;

        }

    }

     

    比较器类

    1

    2

    3

    4

    5

    6

    7

    8

    class MapKeyComparator implements Comparator<String>{

     

        @Override

        public int compare(String str1, String str2) {

             

            return str1.compareTo(str2);

        }

    }

     

    2、按值排序

    按值排序就相对麻烦些了,貌似没有直接可用的数据结构能处理类似需求,需要我们自己转换一下。
    Map本身按值排序是很有意义的,很多场合下都会遇到类似需求,可以认为其值是定义的某种规则或者权重。

    原理:将待排序Map中的所有元素置于一个列表中,接着使用Collections的一个静态方法 sort(List<T> list, Comparator<? super T> c) 
    来排序列表,同样是用比较器定义比较规则。排序后的列表中的元素再依次装入Map,为了肯定的保证Map中元素与排序后的List中的元素的顺序一致,使用了LinkedHashMap数据类型。

     

    实现代码

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    public class MapSortDemo {

     

        public static void main(String[] args) {

     

            Map<String, String> map = new TreeMap<String, String>();

     

            map.put("KFC", "kfc");

            map.put("WNBA", "wnba");

            map.put("NBA", "nba");

            map.put("CBA", "cba");

     

            Map<String, String> resultMap = sortMapByKey(map);    //按Key进行排序

    //      Map<String, String> resultMap = sortMapByValue(map); //按Value进行排序

     

            for (Map.Entry<String, String> entry : resultMap.entrySet()) {

                System.out.println(entry.getKey() + " " + entry.getValue());

            }

        }

         

        /**

         * 使用 Map按value进行排序

         * @param map

         * @return

         */

        public static Map<String, String> sortMapByValue(Map<String, String> oriMap) {

            if (oriMap == null || oriMap.isEmpty()) {

                return null;

            }

            Map<String, String> sortedMap = new LinkedHashMap<String, String>();

            List<Map.Entry<String, String>> entryList = new ArrayList<Map.Entry<String, String>>(

                    oriMap.entrySet());

            Collections.sort(entryList, new MapValueComparator());

     

            Iterator<Map.Entry<String, String>> iter = entryList.iterator();

            Map.Entry<String, String> tmpEntry = null;

            while (iter.hasNext()) {

                tmpEntry = iter.next();

                sortedMap.put(tmpEntry.getKey(), tmpEntry.getValue());

            }

            return sortedMap;

        }

    }


    比较器类

    1

    2

    3

    4

    5

    6

    7

    8

    class MapValueComparator implements Comparator<Map.Entry<String, String>> {

     

        @Override

        public int compare(Entry<String, String> me1, Entry<String, String> me2) {

     

            return me1.getValue().compareTo(me2.getValue());

        }

    }

    例:

    在一个仓库里,有一排条形码,其中第 i 个条形码为 barcodes[i]

    请你重新排列这些条形码,使其中两个相邻的条形码 不能 相等。 你可以返回任何满足该要求的答案,此题保证存在答案。

    class Solution {
        public int[] rearrangeBarcodes(int[] barcodes) {
            int[] res=new int[barcodes.length];
            int j=0;
            Map<Integer,Integer> map=new LinkedHashMap<>();
            for(int i=0;i<barcodes.length;i++){
                map.putIfAbsent(barcodes[i],0);
                map.put(barcodes[i],map.get(barcodes[i])+1);
            }
            ArrayList<Map.Entry<Integer,Integer>> list=new ArrayList<>(map.entrySet());
            Collections.sort(list,new c());
            Iterator itr=list.iterator();
            Map.Entry<Integer, Integer> tmpEntry = null;
            while(itr.hasNext()){
                tmpEntry=(Map.Entry<Integer,Integer>)itr.next();
                int num=tmpEntry.getValue();
                int n=tmpEntry.getKey();
                for(int i=0;i<num;i++){
                    res[j]=n;
                    j+=2;
                    if(j>=res.length){
                        j=1;
                    }
                }
            }
            return res;
        }
    }
    class c implements Comparator<Map.Entry<Integer,Integer>>{
        public int compare(Map.Entry<Integer,Integer> m1,Map.Entry<Integer,Integer> m2){
            return -(m1.getValue()-m2.getValue());
        }
    }

     

    展开全文
  • 主要介绍了java如何对map进行排序,java map集合的使用详解,大家可以参考使用
  • Java Map排序详解

    千次阅读 2020-04-25 22:30:16
    一)Map简介 java.util.Map是一个键值对集合接口,它的实现类主要包括:HashMap,TreeMap,Hashtable以及LinkedHashMap等。 HashMap:最常用的Map,它根据key的hashCode值来存储数据,根据key可以直接获取它的...

    一)Map简介

    java.util.Map是一个键值对集合接口,它的实现类主要包括:HashMap,TreeMap,Hashtable以及LinkedHashMap等。

    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排序

    Map排序原理:先把Map转换成List,再根据Map的key或者value来排序

    package com.oysept.map;
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.HashMap;
    import java.util.LinkedHashMap;
    import java.util.List;
    import java.util.Map;
    import java.util.Map.Entry;
    
    public class MapSort {
    
        public static void main(String[] args) {
            Map<String, String> map1 = new HashMap<String, String>();
            map1.put("aaa", "333");
            map1.put("ccc", "222");
            map1.put("bbb", "111");
    		
            // 第一种Map排序方式, 根据key排序
            List<Map.Entry<String, String>> entryList1 = new ArrayList<Map.Entry<String, String>>(map1.entrySet());
            Collections.sort(entryList1, new Comparator<Map.Entry<String, String>>() {
                @Override
                public int compare(Entry<String, String> me1, Entry<String, String> me2) {
                    return me1.getKey().compareTo(me2.getKey()); // 升序排序
                    //return me2.getKey().compareTo(me1.getKey()); // 降序排序
                }
            });
            System.out.println("第一种Map排序方式, 根据key排序: \n" + entryList1);
    		
            // 第一种Map排序方式, 根据value排序
            List<Map.Entry<String, String>> entryList2 = new ArrayList<Map.Entry<String, String>>(map1.entrySet());
            Collections.sort(entryList2, new Comparator<Map.Entry<String, String>>() {
                @Override
                public int compare(Entry<String, String> me1, Entry<String, String> me2) {
                    return me1.getValue().compareTo(me2.getValue()); // 升序排序
                    //return me2.getValue().compareTo(me1.getValue()); // 降序排序
                }
            });
            System.out.println("\n第一种Map排序方式, 根据value排序结果: \n" + entryList2);
    		
            // 有序LinkedHashMap, 第一种Map排序方式, 根据key排序
            Map<String, String> result1 = new LinkedHashMap<String, String>();
            map1.entrySet()
                .stream().sorted(Map.Entry.comparingByKey())
                .forEachOrdered(x -> result1.put(x.getKey(), x.getValue()));
            System.out.println("\n有序LinkedHashMap, 第一种Map排序方式, 根据key排序: \n" + result1);
    		
            // 有序LinkedHashMap, 第一种Map排序方式, 根据value排序
            Map<String, String> result2 = new LinkedHashMap<>();
            map1.entrySet()
                .stream().sorted(Map.Entry.comparingByValue())
                .forEachOrdered(x -> result2.put(x.getKey(), x.getValue()));
            System.out.println("\n有序LinkedHashMap, 第一种Map排序方式, 根据value排序: \n" + result2);
        }
    }

    控制台效果图打印:

     

    识别二维码关注个人微信公众号

    本章完结,待续,欢迎转载!
     
    本文说明:该文章属于原创,如需转载,请标明文章转载来源!

    展开全文
  • java Map转Bean Bean转Map Map排序
  • c++中map排序

    千次阅读 2017-10-18 15:40:32
    首先,得说明,在c++中有两个关联容器,第一种是map,内部是按照key排序的,第二种是unordered_map,容器内部是无序的,使用hash组织内容的。对有序map中的key排序如果在有序的map中,key是int,或者string,它们...
  • JDK8 之 Map 排序

    2020-03-29 17:20:31
    JDK8 之 Map 排序 public class MapUtil { /** * JDK8 * 按照Key排序 * * @param map map数据 * @param asc 是否升序 * @param <K> Key * @param <V> Value * @return ...
  • [C++] unordered_map排序

    千次阅读 2020-04-28 20:44:37
    最近在业务开发的过程中,遇到对unordered_map排序的问题,并且map中的元素类型较为复杂。将具体的业务问题,抽象为如下较易理解的问题。 问题: 在若干名学生中,挑选出2名学生。挑选依据:根据学生所有课程中,...
  • C++的map排序

    万次阅读 多人点赞 2019-05-04 19:07:21
    map排序默认按照key从小到大进行排序,但有以下几点需要注意: 1按照key从大到小进行排序。 2key的第1个元素是结构体。 3想按value(第二个元素)排序。 二让map中的元素按照key从大到小排序 1代码 #...
  • golang map 排序 key value

    千次阅读 2020-07-14 14:57:25
    go语言的map是无序的,多次遍历map的结果可能是不同的 举例如下: package main import ( "fmt" ) // GetMap 得到map func GetMap() (result map[int]uint32) { result = map[int]uint32{} // 压入各个数据 ...
  • Map排序,按key排序,按value排序。

    千次阅读 2018-12-26 15:32:21
    利用TreeMap,TreeMap中的数据是根据key值对象中的对比方法(comparaTo)的运行结果进行存储,所以可以直接利用TreeMap将Map中的key进行排序。 2、按照value排序: 将待排序Map中的所有元素置于一个list列表中,...
  • Kotlin中的Map排序

    千次阅读 2020-09-04 18:22:07
    示例代码如下: fun main() { ...从上面例子可以看到,有序Map的实现类是TreeMap,它默认是对key进行升序排序。TreeMap的构造方法中可以接收一个比较器,是用于比较key的,所以如果我们希望降序,则可以通
  • map排序.go

    2019-09-14 19:56:18
    map排序
  • lambda表达式对map排序

    千次阅读 2019-07-04 20:58:10
    public static <K, V extends Comparable<? super V>... Map<K, V> sortByValue(Map<K, V> map, boolean asc) { Map<K, V> result = new LinkedHashMap<>(); ...
  • 如何给list集合中的map排序

    千次阅读 2020-06-22 20:43:39
    //给list集合中的map排序 public class Demo2 { public static void main(String[] args) { List<Map<String, Object>> list = new ArrayList<>(); for (int i = 0; i < 5; i++) { Map...
  • [每日知识点] lambda表达式map排序

    千次阅读 2019-08-07 18:05:24
    先记录一下map 利用lambda表达式排序 import java.util.Collections; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.Map; import java.util.stream.Collectors; ...
  • python Map 排序

    千次阅读 2018-05-03 23:08:23
    python字典按照value进行排序 例子如下: &gt;&gt;&gt; d = {'a':1,'b':4,'c':2} &gt;&gt;&gt; f = zip(d.values(), d.keys() ) &gt;&gt;&gt; f [(1, 'a'), (2, 'c'), (4, ...
  • map排序方法

    千次阅读 2016-06-19 09:46:45
    map的进行排序: 1.key排序是默认的,从小到大默认排序 2.value需要借助vector进行排序,首先把map中数据放到vector中,然后利用sort对vector排序 struct User{ int score[MaxK]; int sum; int full_cnt; int ...
  • java8使用lambda对Map排序

    万次阅读 2017-04-11 15:56:57
    java8以前要对map排序比较繁琐复杂,使用java8的lambda表达式排序要简单很多,直接上代码 public static void main(String[] args) { // 初始数据 Map smap = new HashMap(); smap.put("1", 11); smap.put...
  • Map中元素存放是无序的 HashMap注意事项: 1,HashMap底层维护一个数组,我们向HashMap中所放置的对象实际上是存储在该数组当中; 2,当向HashMap中put一对键值时,它会根据key的hashCode值计算出一个位置,该位置...
  • map排序及url参数拼接

    千次阅读 2018-05-25 11:22:19
    map升序排序// 1.7key排序 ArrayList&lt;Map.Entry&lt;String, String&gt;&gt; list = new ArrayList&lt;Map.Entry&lt;String, String&gt;&gt;(paramMap.entrySet()); ...
  • 主要介绍了java实现对map的字典序排序操作,结合实例形式分析了java参照微信官网算法实现的字典序排序操作相关实现技巧,需要的朋友可以参考下
  • 主要介绍了java8 stream 操作map根据key或者value排序的实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • go语言之map排序

    千次阅读 2018-05-30 16:04:59
    package main import ( "sort" "fmt" ) ... var mp map[string]int mp = make(map[string]int) mp["1"] = 1 mp["5"] = 45 mp["6"] = 3 mp[".
  • public DcenterServer getFreeServer(Map<Long, DcenterServer> availableServer) { // 降序 Comparator<Map.Entry<Long, DcenterServer>> valueComparator = new Comparator<Map.Entry&...
  • scala map排序

    千次阅读 2017-06-29 16:52:20
    def main(args: Array[String]): Unit = { val aMap = new scala.collection.mutable.HashMap[String, Double] val a = Array("A", "B", "C", "D") val b = Array(4, 5, 8, 9) for(i ){
  • STL容器(三)——对map排序

    万次阅读 多人点赞 2014-12-12 09:18:53
    STL容器(三)——对map排序 对于map的排序问题,主要分为两部分:根据key排序;根据value排序。下面我们就分别说一下~ 1. 根据key进行排序 map默认按照key进行升序排序,和输入的顺序无关。如果是int/double...
  • Java 8 – 怎样对Map排序

    万次阅读 2017-11-05 11:19:15
    在Java 8 中使用Stream 例子对一个 Map 进行按照keys或者values排序. ...将 Map 转换为 Stream对其进行排序Collect and return a new LinkedHashMap (保持顺序) Map result = map.entrySet().stream() .
  • Java 8 – Map排序

    千次阅读 2016-09-12 11:16:38
    1.根据key排序: import java.util.HashMap; import java.util.LinkedHashMap; import java.util.Map; public class SortByKeyExample { public static void main(String[] argv) { Map unsortMap = new

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 411,684
精华内容 164,673
关键字:

map排序