精华内容
下载资源
问答
  • 主要介绍了java如何对map进行排序,java map集合的使用详解,大家可以参考使用
  • c++对map进行排序

    万次阅读 多人点赞 2016-05-31 15:05:11
    c++对map进行排序。总结了基于Key值排序和基于Value排序的方法。

              最近在PAT刷题,其中一道题月饼 (25)需要用到对价格进行排序,但是排序后要用到价格对应的总售价。因而可以考虑用关联容器进行求解,map是比较合适这题的数据结构。

            map是用来存放<key, value>键值对的数据结构,可以很方便快速的根据key查到相应的value。关于map的详细定义及用法可以见C++STL之map学习。假如存储学生和其成绩,我们用map来进行存储就是个不错的选择。 我们这样定义map<string, int>,其中学生姓名用string类型,作为Key;该学生的成绩用int类型,作为value。我们可以根据学生姓名快速的查找到他的成绩。另一方面,如果我们想把所有同学和他相应的成绩都输出来,并且按照我们想要的顺序进行输出:比如按照学生姓名的顺序进行输出,或者按照学生成绩的高低进行输出。换句话说,我们希望能够对map进行按Key排序或按Value排序。本文对这两种排序进行一个简单的总结。


    一、按Key排序

           我们知道,map内部本身就是按序存储的(比如红黑树),这样方便实现快速查找。在我们插入<key, value>键值对时,map就会自动按照key的大小顺序进行存储。因而作为key的类型必须能够进行大小运算的比较。比如int、double、string、char等类型。以月饼 (25)这一题为背景例子进行编程说明。

    //按Key排序
    #include<iostream>
    #include<vector>
    #include<map>
    #include<iomanip>
    
    using namespace std;  
    
    int main()
    {
    	double N,maxneed,tm,ts;
    	cin>>N>>maxneed;
    	vector<double> vm,vs,vp;//vm是总量,vs是总销售额,vp是价格
    	for(int i = 1;i<=N;++i)
    	{
    		cin>>tm;
    		vm.push_back(tm);
    	}
    	for(int i = 1;i<=N;++i)
    	{
    		cin>>ts;
    		vs.push_back(ts);
    	}
    	for(int i = 0;i<N;++i)
    		vp.push_back(vs[i]/vm[i]);
    
    	map<double,double> m;
    	for(int i = 0;i<N;++i)
    		m.insert(make_pair(vp[i],vs[i]));//插入后自动按Key值进行排序
    	cout<<"按Key排序结果:"<<endl;
    	for(map<double,double>::iterator it=m.begin();it!=m.end();++it)
    		cout<<it->first<<" "<<it->second<<endl;
    
    	system("pause");
    	return 0;
    }

    结果如下:


           从结果可以看到未对map进行任何操作,它按照Key值自动进行了排序。

           具体到月饼 (25)这一题上,详细分析可以见另外一篇博客PAT上面一道关于“月饼”的题目的解法

           另举一例进行说明:

    #include<iostream>
    #include<map>  
    #include<string>  
      
    using namespace std;  
      
    typedef pair<string, int> PAIR;  
      
    ostream& operator<<(ostream& out, const PAIR& p) 
    {  
    	return out << p.first << "\t" << p.second;  
    }  
      
    int main() 
    {  
    	map<string, int> name_score_map;  
    	name_score_map["LiMin"] = 90;   
        name_score_map["ZiLinMi"] = 79;   
        name_score_map["BoB"] = 92;   
        name_score_map.insert(make_pair("Bing",99));  
        name_score_map.insert(make_pair("Albert",86));  
        for (map<string, int>::iterator iter = name_score_map.begin();  
    		iter != name_score_map.end();  
    		++iter) {  
    		cout << *iter << endl;  
    	}  
    	system("pause");
    	return 0;  
     } 
    结果如下:


    上面的按key值排序有个缺点:即当插入的有多个相等的值时,由于key的唯一性,会只保留一个。因此月饼 (25)这一题不适合用按key进行排序求解(因为不排斥某两种月饼的价格相等)。


    二、按Value排序

            如何实现Map的按Value排序呢?

            第一反应是利用STL中提供的sort算法实现,这个想法是好的,不幸的是,sort算法有个限制,利用sort算法只能对序列容器进行排序,就是线性的(如vector,list,deque)。map是一个集合容器,它里面存储的元素是pair,但是它不是线性存储的(像红黑树),所以利用sort不能直接和map结合进行排序。因而可以采用一些其它的思路,总结如下:


    思路1:可以考虑将value作为key值进行自动排序。

    思路2:可以把map中的key值和value值分别转存到一个pair类型的vector中,在对vector按照一定的规则排序即可。这样的方法对值一样的情况也能够使用。具体代码如下:

    //功能:输入单词,统计单词出现次数并按照单词出现次数从多到少排序  
    #include <iostream>
    #include <cstdlib>  
    #include <map>  
    #include <vector>  
    #include <string>  
    #include <algorithm>  
    
    using namespace std;
       
    int cmp(const pair<string, int>& x, const pair<string, int>& y)  
    {  
    	return x.second > y.second;  
    }  
       
    void sortMapByValue(map<string, int>& tMap,vector<pair<string, int> >& tVector)  
    {  
    	for (map<string, int>::iterator curr = tMap.begin(); curr != tMap.end(); curr++)   
    		tVector.push_back(make_pair(curr->first, curr->second));    
       
    	sort(tVector.begin(), tVector.end(), cmp);  
    }  
    int main()  
    {  
    	map<string, int> tMap;  
    	string word;  
    	while (cin >> word)  
    	{  
    		pair<map<string,int>::iterator,bool> ret = tMap.insert(make_pair(word, 1));  
    		if (!ret.second)  
    			++ret.first->second;  
    	}   
       
    	vector<pair<string,int>> tVector;  
    	sortMapByValue(tMap,tVector);  
    	for(int i=0;i<tVector.size();i++)  
    		cout<<tVector[i].first<<": "<<tVector[i].second<<endl;  
       
    	system("pause");  
    	return 0;  
    }  

    结果如下:



    参考资料

    C++ STL中Map的按Key排序和按Value排序

    C++STL之map学习

    STL中map按值(value)排序

    对map集合进行排序

    STL容器(三)——对map排序

    如何禁止STL map 自动排序

    展开全文
  • 如何对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
    
    展开全文
  • 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

    展开全文
  • Java 对Map进行排序的实现方法

    千次阅读 2016-03-26 11:47:31
    Java 对Map进行排序的实现方法HashMap与TreeMap的区别HashMap:最常用的Map,根据键值可以获取Value值,HashMap通过键值的hash来决定存储的位置,存取速度非常快,同时它的这一性质也决定了它不可能存在键值相同的元素...

    Java 对Map进行排序的实现方法

    HashMap与TreeMap的区别

    HashMap:

    最常用的Map,根据键值可以获取Value值,HashMap通过键值的hash来决定存储的位置,存取速度非常快,同时它的这一性质也决定了它不可能存在键值相同的元素同时存在,后加入的会替换先加入的.使用迭代器输出的顺序是键被添加的顺序,不会进行自动排序

    TreeMap:

    会对存如的元素按键的大小升序排列,使用迭代器输出的时候是有序的,默认升序.

    下面是实现排序的代码

    输出结果的方法

    迭代器输出Map的元素
    public void IteratorPrint(Map map) {
            Set<Integer> set = map.keySet();
            Iterator<Integer> iterator = set.iterator();
            while (iterator.hasNext()) {
                int key = iterator.next();
                int value = (int) map.get(key);
                System.out.println(key + ":" + value);
            }
        }
    输出List<Map.Entry<Integer,Integer>>的方法
    public void ListPrint(List<Map.Entry<Integer,Integer>> list) {
            for (int i = 0; i < list.size(); i++) {
                Map.Entry<Integer, Integer> map = list.get(i);
                System.out.println(map.getKey()+":"+map.getValue());
            }
        }

    按键的升序的方法(默认的)

    Map<Integer, Integer> map1 = new TreeMap<>();
            map1.put(3, 2);
            map1.put(4, 6);
            map1.put(2, 5);
            map1.put(1, 3);
            IteratorPrint(map1);
    输出结果
    1:3
    2:5
    3:2
    4:6

    按键的降序的方法

    //实例化时传入`Comparator`
    Map<Integer, Integer> map2 = new TreeMap<>(new Comparator<Integer>() {
                @Override
                public int compare(Integer o1, Integer o2) {
    
                    return o2 - o1;
                }
            });
            map2.put(3, 2);
            map2.put(4, 6);
            map2.put(2, 5);
            map2.put(1, 3);
            //输出
            IteratorPrint(map2);
    输出
    4:6
    3:2
    2:5
    1:3

    按值的升降排序的方法(升序降序就一行代码的差距)

    Map<Integer, Integer> map3 = new TreeMap<>();
            map3.put(3, 2);
            map3.put(4, 6);
            map3.put(2, 5);
            map3.put(1, 3);
            //Map转ArrayList
            List<Map.Entry<Integer, Integer>> list = new ArrayList<Map.Entry<Integer, Integer>>(map3.entrySet());
            Collections.sort(list, new Comparator<Map.Entry<Integer, Integer>>() {
                @Override
                public int compare(Map.Entry<Integer, Integer> o1, Map.Entry<Integer, Integer> o2) {
                    //升序
                    return o1.getValue()-o2.getValue();
                    //降序
    //                return o2.getValue()-o1.getValue();
                }
            });
            //输出
            ListPrint(list);

    输出就不贴了,跟上面的一样

    主要代码都上了,最后贴一下测试代码,复制可运行

    import java.util.*;
    
    /**
     * Created by Brioal on 2016/3/26.
     */
    public class TreeMapTest {
        public TreeMapTest() {
            //map按键升序(默认)
            System.out.println("Map按键升序");
            Map<Integer, Integer> map1 = new TreeMap<>();
            map1.put(3, 2);
            map1.put(4, 6);
            map1.put(2, 5);
            map1.put(1, 3);
            IteratorPrint(map1);
    
            //map按键降序
            System.out.println("Map按键降序");
            Map<Integer, Integer> map2 = new TreeMap<>(new Comparator<Integer>() {
                @Override
                public int compare(Integer o1, Integer o2) {
    
                    return o2 - o1;
                }
            });
            map2.put(3, 2);
            map2.put(4, 6);
            map2.put(2, 5);
            map2.put(1, 3);
            IteratorPrint(map2);
    
    
            //map按value升降序
            System.out.println("Map按值升降序");
            Map<Integer, Integer> map3 = new TreeMap<>();
            map3.put(3, 2);
            map3.put(4, 6);
            map3.put(2, 5);
            map3.put(1, 3);
            List<Map.Entry<Integer, Integer>> list = new ArrayList<Map.Entry<Integer, Integer>>(map3.entrySet());
            Collections.sort(list, new Comparator<Map.Entry<Integer, Integer>>() {
                @Override
                public int compare(Map.Entry<Integer, Integer> o1, Map.Entry<Integer, Integer> o2) {
                    //升序
                    return o1.getValue()-o2.getValue();
                    //降序
    //                return o2.getValue()-o1.getValue();
                }
            });
            ListPrint(list);
        }
    
        public void ListPrint(List<Map.Entry<Integer,Integer>> list) {
            for (int i = 0; i < list.size(); i++) {
                Map.Entry<Integer, Integer> map = list.get(i);
                System.out.println(map.getKey()+":"+map.getValue());
            }
        }
    
        public void IteratorPrint(Map map) {
            Set<Integer> set = map.keySet();
            Iterator<Integer> iterator = set.iterator();
            while (iterator.hasNext()) {
                int key = iterator.next();
                int value = (int) map.get(key);
                System.out.println(key + ":" + value);
            }
        }
    
        public static void main(String[] args) {
            new TreeMapTest();
        }
    }
    
    展开全文
  • 但是,无论实际中使用哪种实现,我们在编程过程中常常会遇到诸如根据Key或Value对Map进行排序、保持Map插入顺序等问题,本文特别针对以上几个问题给出了具体解法,并分享华为一道与我们主题极为相关的笔试题。
  • 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...
  • 根据value字段对map进行排序

    千次阅读 2011-11-04 18:06:44
    一般来说,我们通常都是通过map中的...一、根据key对map进行排序 TreeMap map = new TreeMap(new Comparator(){ //直接添加比较器 public int compare(String o1,String o2){  .....  } }); 但是却没有直接
  • Java8 对Map进行排序

    千次阅读 2019-03-14 18:52:53
    随着Java 8的Stream之后推出后可以很优雅实现Map排序。 示例: final Map&lt;String, Integer&gt; wordCounts = new HashMap&lt;&gt;(); wordCounts.put("USA", 100); wordCounts....
  • 使用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(...
  • java如何对map进行排序详解

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

    千次阅读 2017-01-19 18:02:13
    * 对map进行降序排列 * @param goodsCateMap * @return */ private Map Descending(Map goodsCateMap) { List> list = new LinkedList>(goodsCateMap.entrySet()); Collections.sort(list, new ...
  • Java对map进行排序并生成序号

    千次阅读 2017-11-13 14:43:49
    最近做的项目有这样一个需求:要求对map中的值进行排序并生成序号。如果值相等则序号不变;如果不相等序号为该数数值在所有元素中的索引。如下表所示: Key(String) Value(Float) Idx 23 12.4 1 10 3.2 2 ...
  • 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对map进行排序日期倒叙)

    千次阅读 2017-02-05 13:50:00
    工作中遇到这样一个问题,需要一个map,key中存放的是日期比如 2016-01-01,但是我还需要这个map中的日期倒序排列。 ###首先有下面两个概念 HashMap:我们最常用的Map,它根据key的HashCode 值来存储数据,根据key...
  • 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...
  • import java.util.*; public class treeMap { static String key1 =""; static Integer vlue1 ; public static void main(String [] arg){ Map<String,Integer> map = new TreeMap<...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 406,697
精华内容 162,678
关键字:

对map进行排序