HashMap排序题，要求如下：写一个方法，传给该方法一个HashMap<Integer,User>参数,要求按照该hashMap的User的age的倒序排序，返回一个HashMap或者其子类。User 有age 和name属性。该题并不难，但是综合考察了集合常见的类，List ，Set，Map以及Collections等。希望大家踊跃思考，将正确的答案回复过来。五一过后公布正确答案。

1. public class GetSortMap
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 User u1 = new User("zhangsan1",11);
   
6.                 User u2 = new User("zhangsan2",8);
   
7.                 User u3 = new User("zhangsan3",9);
   
8.                 User u4 = new User("zhangsan4",12);
   
9.                 User u5 = new User("zhangsan5",6);
   
10.                        
    
11.                 Map<Integer, User> map = new HashMap<Integer, User>();
    
12.                
    
13.                 map.put(1, u1);
    
14.                 map.put(2, u2);
    
15.                 map.put(3, u3);
    
16.                 map.put(4, u4);
    
17.                 map.put(5, u5);
    
18. 
    
19.                 System.out.println("before sorted...................");
    
20.                 showMap(map);
    
21. 
    
22.                 Map<Integer, User> sortmap =  getSortedMap(map);
    
23. 
    
24.                 System.out.println("after sorted......................");
    
25.                 showMap(sortmap);
    
26.                
    
27.                
    
28.         }
    
29.        
    
30.         public static Map<Integer, User> getSortedMap(Map<Integer, User> map)
    
31.         {
    
32.                 //在TreeMap构造函数中传入一个反向比较器对User按age进行反向排序
    
33.                 Map<User,Integer> tMap = new TreeMap<User,Integer>(Collections.reverseOrder());
    
34.                 //根据LinkedHashMap在重新插入键对插入顺序并不影响，将TreeMap中排序好的元素重新装入LinkedHashMap中。
    
35.                 Map<Integer, User> retMap = new LinkedHashMap<Integer, User>();
    
36.                
    
37.                 Set<Integer> set1 = map.keySet();
    
38.                
    
39.                 for(Integer i: set1)
    
40.                 {
    
41.                         tMap.put(map.get(i),i);
    
42.                 }
    
43.                
    
44.                 Set<User> set2 = tMap.keySet();
    
45.                
    
46.                 for(User user: set2)
    
47.                 {
    
48.                         retMap.put(tMap.get(user), user);
    
49.                 }
    
50.                                
    
51.                 return retMap;
    
52.         }
    
53.        
    
54.         public static void showMap(Map<Integer, User> map)
    
55.         {
    
56.                 Set<Integer> set = map.keySet();
    
57.                 for(Integer i: set)
    
58.                 {
    
59.                         System.out.println(i+".........."+map.get(i));
    
60.                 }
    
61.         }
    
62. 
    
63. }
    
64. 
    
65. 
    
66. User实现了Comparable接口，根据compareTo函数进行比较
    
67. class User implements Comparable<User>
    
68. {
    
69.         private String name;
    
70.         private int age;
    
71.        
    
72.        
    
73.         public User(String name,int age)
    
74.         {
    
75.                 this.name = name;
    
76.                 this.age = age;
    
77.         }
    
78.        
    
79.         @Override
    
80.         public int compareTo(User o) {
    
81.                
    
82.                 return ( this.age - o.age);
    
83.                
    
84.         }
    
85.        
    
86.         public String toString()
    
87.         {
    
88.                 return this.age+"";
    
89.         }
    
90.        
    
91.         @Override
    
92.         public boolean equals(Object obj) {
    
93.                
    
94.                 if(!(obj instanceof User))
    
95.                         throw new RuntimeException("case match error!!!");
    
96.                
    
97.                 User u = (User)obj;
    
98.                 return this.getName().equals(u.getName()) && this.age == u.age;
    
99.         }
    
100. 
     
101. 
     
102. 
     
103.         public String getName() {
     
104.                 return this.name;
     
105.         }
     
106.         public void setName(String name) {
     
107.                 this.name = name;
     
108.         }
     
109.         public int getAge() {
     
110.                 return this.age;
     
111.         }
     
112.         public void setAge(int age) {
     
113.                 this.age = age;
     
114.         }
     
115.        
     
116.        
     
117. }

复制代码

观决 发表于 2014-4-29 22:31
/*
HashMap排序题，要求如下：
写一个方法，传给该方法一个HashMap参数,

Collections.sort(list,new myCom());   
myCom implements Comparator<Map.Entry<Integer,User>>{}


//算了还是给个完整的代码吧  Collections.sort()的  (其实也是看了别人才会的自己一下子没想到这个)还有我不晓得那个用已有代码标签是什么意思 额 没怎么弄过....


import java.util.*;

class HashMap排序练习2
{
        public static void main(String[] args)
        {
                Map<Integer,User> hm=new HashMap<Integer,User>();
                //这里就固定传入一些值，没弄输入
                hm.put(1,new User("liubo",21));
                hm.put(2,new User("xiaoni",22));
                hm.put(3,new User("xiaochen",18));
                hm.put(4,new User("haha",28));
                hm.put(5,new User("hehe",28));
               
                List<Map.Entry<Integer,User>> lists=new ArrayList<Map.Entry<Integer,User>>(hm.entrySet());//按照迭代器存入

                //排序直接用collections.sort()
                Collections.sort(lists,new myCom());
                for(Map.Entry me : lists){
                        System.out.println(me.getKey()+"---"+me.getValue());
                }
        }
}

class User
{
        private String name;
        private int age;
        public User(String name,int age){
                this.name=name;
                this.age=age;
        }
        public String getName(){
                return name;
        }
        public int getAge(){
                return age;
        }
        public String toString(){
                return name+":"+age;
        }
        //hasCode 让其唯一性 存入的时候
        public int hashCode(){
                return name.hashCode()+age*27;
        }
        //User相同条件的比较
        public boolean equals(Object obj){
                if(!(obj instanceof User))
                        throw new ClassCastException("类型不匹配");
       User user=(User)obj;
           return this.name.equals(user.name)&&this.age==user.age;
        }
}

//自定义比较器
class myCom implements Comparator<Map.Entry<Integer,User>>
{
         //这样是新来的大于就在后面    升序
        public int compare(Map.Entry<Integer,User> me1,Map.Entry<Integer,User> me2){   
                User user1=me1.getValue();
                User user2=me2.getValue();
                int num=user1.getAge()-user2.getAge();
                if(num==0){
                        return user1.getName().compareTo(user2.getName());
                }
                return num;
        }
}

/*
HashMap排序题，要求如下：
写一个方法，传给该方法一个HashMap<Integer,User>参数,
要求按照该hashMap的User的age的倒序排序，
返回一个HashMap或者其子类。(这里没有单独定义方法，直接写字主函数中)
User 有age 和name属性。

思路：
hashMap不具备排序   ,
将存入的数据提取存入TreeSet中，
给他一个比较器让集合具备比较性，
Set集合中的数据已经排好序了
然后拿每一个set中的数据，去和原来的hashMap中的数据(Set<Map.Entry>这里面键和值都有)去比较，得出数据存入
LinkedHashMap中
遍历输出

*/
import java.util.*;

class HashMap排序练习
{
        public static void main(String[] args)
        {
                Map<Integer,User> hm=new HashMap<Integer,User>();
                //这里就固定传入一些值，没弄输入
                hm.put(1,new User("liubo",21));
                hm.put(2,new User("xiaoni",22));
                hm.put(3,new User("xiaochen",18));
                hm.put(4,new User("haha",28));
                hm.put(5,new User("hehe",28));
                //将hm中所有的映射关系去取出放入Set集合中
                Set<Map.Entry<Integer,User>> entrySets=hm.entrySet();
                Iterator <Map.Entry<Integer,User>> it=entrySets.iterator();
                //新建一个TreeSet集合  用来存放提取出来的数据，只存入，User 因为根据排序
                        Set <User> set=new TreeSet<User>(new myCom());   //传入比较器，让集合具备比较性，
       //遍历比较的数据存入set
                while(it.hasNext()){
                        Map.Entry<Integer,User> en=it.next();   
                        Integer i=en.getKey();
                        User user=en.getValue();
                        set.add(user);    //将user对象加入
                }
                //遍历set存入LinkedHashMap
                LinkedHashMap<Integer,User> lhm=new LinkedHashMap<Integer,User>();
                for(User user : set){
                        it=entrySets.iterator();
                                while(it.hasNext()){
                                        Map.Entry<Integer,User> en=it.next();
                                //如果相等
                                if(user.equals(en.getValue())){
                                                lhm.put(en.getKey(),user);
                                                break;
                                }
                        }
                }

                System.out.println("经过排序:");
                //输出LinkedhashMap的数据
                Set<Map.Entry<Integer,User>> entryset_lhm=lhm.entrySet();  //存入set

           Iterator<Map.Entry<Integer,User>> it_lhm=entryset_lhm.iterator();

           while(it_lhm.hasNext()){
                        Map.Entry<Integer,User> en_lhm=it_lhm.next();
                        System.out.println(en_lhm.getKey()+"---"+en_lhm.getValue());
           }

        }
}

class User
{
        private String name;
        private int age;
        public User(String name,int age){
                this.name=name;
                this.age=age;
        }
        public String getName(){
                return name;
        }
        public int getAge(){
                return age;
        }
        public String toString(){
                return name+":"+age;
        }
        //hasCode 让其唯一性 存入的时候
        public int hashCode(){
                return name.hashCode()+age*27;
        }
        //User相同条件的比较
        public boolean equals(Object obj){
                if(!(obj instanceof User))
                        throw new ClassCastException("类型不匹配");
       User user=(User)obj;
           return this.name.equals(user.name)&&this.age==user.age;
        }
}

//自定义比较器
class myCom implements Comparator<User>
{
         //这样是新来的大于就在后面    升序
        public int compare(User user1,User user2){   
                int num=user1.getAge()-user2.getAge();
                if(num==0){
                        return user1.getName().compareTo(user2.getName());
                }
                return num;
        }
}

/**
* 写一个方法，传给该方法一个HashMap<Integer,User>参数,
* 要求按照该hashMap的User的age的倒序排序，返回一个HashMap或者其子类。
* User 有age 和name属性。
*/
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.TreeSet;
import java.util.Map.Entry;

public class ShortHashMap {
        public static void main(String[] args) {
                HashMap<Integer, User> map = new HashMap<Integer, User>();
                map.put(1, new User(1, "zhang1"));
                map.put(3, new User(3, "zhang3"));
                map.put(2, new User(2, "zhang2"));
                printMap(shortHashMap(map));
        }
        /**
         * map排序方法
         * @param map
         * @return
         */
        public static HashMap<Integer, User> shortHashMap(HashMap<Integer, User> map) {
                // 通过TreeSet给entrySet排序后再生成LinkedHashMap
                TreeSet<Entry<Integer, User>> ts = new TreeSet<Entry<Integer, User>>(
                                new UserEntryConpartor());
                for (Entry<Integer, User> mapEntry : map.entrySet()) {
                        ts.add(mapEntry);
                }
                return setToMap(ts);
        }
        /**
         * EntrySet转成Map
         * @param ts
         * @return
         */
        public static LinkedHashMap<Integer, User> setToMap(
                        TreeSet<Entry<Integer, User>> ts) {
                LinkedHashMap<Integer, User> hm = new LinkedHashMap<Integer, User>();
                for (Entry<Integer, User> e : ts) {
                        hm.put(e.getKey(), e.getValue());
                }
                return hm;
        }
        public static void printMap(Map<? extends Object, ? extends Object> map) {
                for(Entry<? extends Object, ? extends Object> entry:map.entrySet()){
                        System.out.println("Key: "+entry.getKey()+"---Val: "+entry.getValue());
                       
                }
        }

}
class UserEntryConpartor implements Comparator<Entry<Integer, User>> {

        @Override
        public int compare(Entry<Integer, User> o1, Entry<Integer, User> o2) {
                return -o1.getValue().compareTo(o2.getValue());
        }
}
--------------------------------------------
import java.io.Serializable;
public class User implements Serializable, Comparable<User> {
        private static final long serialVersionUID = 1L;
        private int age;
        private String name;
        public User() {
        }
        public User(int age, String name) {
                super();
                this.age = age;
                this.name = name;
        }
        public int getAge() {
                return age;
        }
        public void setAge(int age) {
                this.age = age;
        }
        public String getName() {
                return name;
        }
        public void setName(String name) {
                this.name = name;
        }
        @Override
        public int hashCode() {
                final int prime = 31;
                int result = 1;
                result = prime * result + age;
                return result;
        }
        @Override
        public boolean equals(Object obj) {
                if (this == obj)
                        return true;
                if (obj == null)
                        return false;
                if (getClass() != obj.getClass())
                        return false;
                User other = (User) obj;
                if (age != other.age)
                        return false;
                return true;
        }
        @Override
        public String toString() {
                return "User [age=" + age + ", name=" + name + "]";
        }
        @Override
        public int compareTo(User o) {
                return this.getAge() == o.getAge() ? this.getName().compareTo(
                                o.getName()) : this.getAge() - o.getAge();
        }
}

王震阳 发表于 2014-4-29 20:09
很好，我可以给你申请技术分，赞一个。。。

谢谢谢谢谢谢谢谢!

微笑=.一瞬间 发表于 2014-4-29 19:24
终于写出来了 来个大家分享下我的程序：import java.util.*;
class HashMapAnswer  
{

很好，我可以给你申请技术分，赞一个。。。

终于写出来了 来个大家分享下我的程序：import java.util.*;
class HashMapAnswer  
{
        public static void main(String[] args)
        {
                User u1=new User();
                User u2=new User();
                User u3=new User();
                User u4=new User();
               
                u1.setName("张三");
                u1.setAge(19);
               
                u2.setName("李四");
                u2.setAge(20);
               
                u3.setName("王五");
                u3.setAge(20);
               
                u4.setName("赵六");
                u4.setAge(11);

                HashMap<Integer,User> hm=new HashMap<Integer,User>();
               
                hm.put(1,u1);
                hm.put(2,u2);
                hm.put(3,u3);
                hm.put(4,u4);
        
                System.out.println("排序前");
               
                put(hm);
               
                hm=getSortHashMap(hm);//返回排序后的结果并用hm接收
               
                System.out.println("排序后");
               
                put(hm);

        }
        // 排序算法
        public static HashMap<Integer,User> getSortHashMap(HashMap<Integer,User> hm)
        {
                /*迭代HashMap结合 在迭代过程中将元素存入TreeMap集合中（
                TreeMap集合能够按指定的方法对存入的元素进行排序--就是按User的age属性进行排序）
                */
                Set<Map.Entry<Integer,User>> entrySet=hm.entrySet();
                Iterator<Map.Entry<Integer,User>> it=entrySet.iterator();
                TreeMap<User,Integer> tm=new TreeMap<User,Integer>(new MyComparator());
                while(it.hasNext())
                {
                        Map.Entry<Integer,User> m=it.next();
                        Integer num=m.getKey();
                        User u=m.getValue();
                        tm.put(u,num);
                }
                /*迭代得到的TreeMap集合 并将迭代过程中的数据存入LinkedHashMap集合中
                （此集合中元素排放顺序就是插入顺序,因此得到按User的age属性排序的集合）
                */
                LinkedHashMap<Integer,User> lhm=new LinkedHashMap<Integer,User>();
                Set<User> keySet=tm.keySet();
                Iterator<User> it1=keySet.iterator();
                while(it1.hasNext())
                {
                        User key=it1.next();
                        Integer v=tm.get(key);
                        lhm.put(v,key);
                }
                // 返回 LinkeHashMap集合的对象
                return lhm;
        }
        //用于输出Map集合的元素
        public static void put(Map t)
        {
                Set<Map.Entry<Integer,User>> entrySet=t.entrySet();
                Iterator<Map.Entry<Integer,User>> it=entrySet.iterator();
               
                while(it.hasNext())
                {
                        Map.Entry<Integer,User> m=it.next();
                        Integer num=m.getKey();
                        User u=m.getValue();
                        System.out.println(num+":"+u.getName()+"--"+u.getAge());
                }
               
        }
}
// 定义按User的age属性排序的比较器
class MyComparator implements Comparator<User>
{
        public int compare(User u1,User u2)
        {
         if(u1.getAge()==u2.getAge())
                         return (u1.getName()).compareTo(u2.getName());
                 return u1.getAge()-u2.getAge();
        }
}
// 定义一个User 类
class User
{
        private String name;
        private int age;
        public int hashCode(){
                return name.hashCode()+age*2;
        }
        public boolean equals(Object obj)
        {
                if(!(obj instanceof User))
                        throw new RuntimeException("插入类型不正确");
                User u=(User)obj;
                return this.getName().equals(u.getName())&& this.getAge()==u.getAge();
        }
        public void setName(String name)
        {
                this.name=name;
        }
        public String getName()
        {
                return name;
        }
        public void setAge(int age)
        {
                this.age=age;
        }
        public int getAge()
        {
                return age;
        }

}
这是运行结果图：