package day1;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class MapTest {
  
          public static void main(String[] args) {
               
                  Map<Person,String> map = new HashMap<Person, String>();
                  
                  map.put(new Person("zhangsan",22), "beijing");
                  map.put(new Person("lisi",28), "shanghai");
                  map.put(new Person("wangwu",31), "tianjin");
                  map.put(new Person("dasha",37), "heilongjiang");

                  Set<Person> me = map.keySet();
                  for( Iterator<Person> it  =   me.iterator();it.hasNext();){
                          
                                    Person s=it.next();
                                    String value=  map.get(s);      
                                   
                              System.out.println(s.getName()+"......"+s.getAge()+"............"+value);      
                                   
                          
                  }
                  
                                  Set<Map.Entry<Person, String>> iter =   map.entrySet();
                                  Iterator<Map.Entry<Person, String>>  em=iter.iterator();
                                 
                              while(em.hasNext()){
                                      
                                              Map.Entry<Person, String> m=em.next();
                                              Person pe= m.getKey();
                                              String s    = m.getValue();
                                  System.out.println(s+"........................."+pe.getName()+"........."+pe.getAge());  
                                      
                              }
        }
       
}

class Person  implements  Comparable<Person>{
       
       
        private String name ;
        private int age;
       
        public Person(String name ,int age){
               
                  this.name = name;
                  this.age = age;
        }

        public String getName() {
                return name;
        }

        public void setName(String name) {
                this.name = name;
        }

        public int getAge() {
                return age;
        }

        public void setAge(int age) {
                this.age = age;
        }

        @Override
        public String toString() {
                return "Person [name=" + name + ", age=" + age + "]";
        }

        @Override
        public int hashCode() {    //这里是比较的什么啊，， 不太明白，  如果属性比较多的话，该怎么比较，age*34是什么意思？
         
                  return name.hashCode()+age*34;
        }
       

        @Override
        public boolean equals(Object obj) {
         
                 if(!(obj instanceof Person))
                          throw  new ClassCastException("类型转换异常");
               
                       Person p= (Person)  obj;
                 
                       return this.name.equals(p.name) && this.age== p.age;
               
        }

        @Override
        public int compareTo(Person o) {   // 还有这里，我明明排序了， 为啥不是按年龄排序的。  如果该从小到大，这该怎么写。
               
                  int num= new Integer(this.age).compareTo(new Integer(o.age));
                  
                   if(num==0)
                          
                    return    this.name.compareTo(o.name);
               
                return num;
        }

}

1. public class Main {
   
2.         public static void main(String[] args) {
   
3.                 Map<Person, String> map = new HashMap<Person, String>();
   
4.                 map.put(new Person("zhangsan", 22), "beijing");
   
5.                 map.put(new Person("lisi", 28), "shanghai");
   
6.                 map.put(new Person("wangwu", 31), "tianjin");
   
7.                 map.put(new Person("dasha", 37), "heilongjiang");
   
8.                 Set<Person> me = map.keySet();
   
9.                 for (Iterator<Person> it = me.iterator(); it.hasNext();) {
   
10.                         Person s = it.next();
    
11.                         String value = map.get(s);
    
12.                         System.out.println(s.getName() + "......" + s.getAge()+ "............" + value);
    
13.                 }
    
14.                 Set<Map.Entry<Person, String>> iter = map.entrySet();
    
15.                 Iterator<Map.Entry<Person, String>> em = iter.iterator();
    
16.                 while (em.hasNext()) {
    
17.                         Map.Entry<Person, String> m = em.next();
    
18.                         Person pe = m.getKey();
    
19.                         String s = m.getValue();
    
20.                         System.out.println(s + "........................." + pe.getName()+ "........." + pe.getAge());
    
21.                 }
    
22.                <font color="Red"> Person[] ps = new Person[me.size()];//注意从这里开始，我加的用于排序的
    
23.                 ps = me.toArray(ps);
    
24.                 Arrays.sort(ps);
    
25.                 System.out.println(Arrays.asList(ps));//使用Person里的compareTo进行比较</font>
    
26.         }
    
27. }
    
28. class Person implements Comparable<Person> {
    
29.         private String name;
    
30.         private int age;
    
31.         public Person(String name, int age) {
    
32.                 this.name = name;
    
33.                 this.age = age;
    
34.         }
    
35.         public String getName() {
    
36.                 return name;
    
37.         }
    
38.         public void setName(String name) {
    
39.                 this.name = name;
    
40.         }
    
41.         public int getAge() {
    
42.                 return age;
    
43.         }
    
44.         public void setAge(int age) {
    
45.                 this.age = age;
    
46.         }
    
47.         @Override
    
48.         public String toString() {
    
49.                 return "Person [name=" + name + ", age=" + age + "]";
    
50.         }
    
51.         @Override
    
52.        <font color="Red"> public int hashCode() { //这里不是在比较，这是在计算此对象的哈希码,至于此方法有什么用，请看张孝祥老师的高新技术26
    
53.                 return name.hashCode() + age * 34;
    
54.         }</font>
    
55.         @Override
    
56.         public boolean equals(Object obj) {
    
57.                 if (!(obj instanceof Person))
    
58.                         throw new ClassCastException("类型转换异常");
    
59.                 Person p = (Person) obj;
    
60.                 return this.name.equals(p.name) && this.age == p.age;
    
61.         }
    
62.        <font color="Red"> @Override
    
63.         public int compareTo(Person o) { //这是我修改后的，你要明白什么时候分别返回正、负、零
    
64.                 if (this.getAge() > o.getAge()) {
    
65.                         return 1;
    
66.                 } else if (this.getAge() == o.getAge()) {
    
67.                         return 0;
    
68.                 } else {
    
69.                         return -1;
    
70.                 }
    
71.         }</font>
    
72. }

复制代码

赵兵锋 发表于 2012-6-14 04:44

• package day1;
  
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.Map;
  import java.util.Set;
  
  public class MapTest {
    
            public static void main(String[] args) {
                 
                    Map<Person,String> map = new HashMap<Person, String>();
                    
                    map.put(new Person("zhangsan",22), "beijing");
                    map.put(new Person("lisi",28), "shanghai");
                    map.put(new Person("wangwu",31), "tianjin");
                    map.put(new Person("dasha",37), "heilongjiang");
  
                    Set<Person> me = map.keySet();
                    for( Iterator<Person> it  =   me.iterator();it.hasNext();){
                             
                                      Person s=it.next();
                                      String value=  map.get(s);      
                                      
                                System.out.println(s.getName()+"......"+s.getAge()+"............"+value);      
                                      
                            
                    }
                    
                                    Set<Map.Entry<Person, String>> iter =   map.entrySet();
                                    Iterator<Map.Entry<Person, String>>  em=iter.iterator();
                                   
                                while(em.hasNext()){
                                        
                                                Map.Entry<Person, String> m=em.next();
                                                Person pe= m.getKey();
                                                String s    = m.getValue();
                                    System.out.println(s+"........................."+pe.getName()+"........."+pe.getAge());  
                                        
                                }
          }
          
  }
  
  class Person  implements  Comparable<Person>{
          
          
          private String name ;
          private int age;
          
          public Person(String name ,int age){
                 
                    this.name = name;
                    this.age = age;
          }
  
          public String getName() {
                  return name;
          }
  
          public void setName(String name) {
                  this.name = name;
          }
  
          public int getAge() {
                  return age;
          }
  
          public void setAge(int age) {
                  this.age = age;
          }
  
          @Override
          public String toString() {
                  return "Person [name=" + name + ", age=" + age + "]";
          }
  
          @Override
          public int hashCode() {    //这里是重写了hashCode，这是为了维护hashCode方法的常规规定，声明相等对象必须具有相等的散列吗，可以简单地说是为你重写equals做准备
           
                    return name.hashCode()+age*34;
          }
          
  
          @Override
          public boolean equals(Object obj) {
           
                   if(!(obj instanceof Person))
                            throw  new ClassCastException("类型转换异常");
                 
                         Person p= (Person)  obj;
                   
                         return this.name.equals(p.name) && this.age== p.age;
                 
          }
  
  public int compareTo(Person o) {
  

      /*
     还有这里，我明明排序了， 为啥不是按年龄排序的。  如果该从小到大，这该怎么写。
               
                      int num= new Integer(this.age).compareTo(new Integer(o.age));
                  
                      if(num==0)
                           
                       return    this.name.compareTo(o.name);//如果要从大到小，只要改变this与传入值的位置。
               
                    return num;*/
       int num=this.age>o.age;
       if(num==0)
                return this.name.compareTo(o.name);
      return num;


}
      

1. import java.util.HashMap;
   
2. import java.util.Iterator;
   
3. import java.util.Map;
   
4. import java.util.Set;
   
5. import java.util.TreeSet;
   
6. 
   
7. public class MapTest {
   
8.   
   
9.           public static void main(String[] args) {
   
10.                
    
11.                   Map<Person,String> map = new HashMap<Person, String>();
    
12.                   
    
13.                   map.put(new Person("zhangsan",22), "beijing");
    
14.                   map.put(new Person("lisi",28), "shanghai");
    
15.                   map.put(new Person("wangwu",31), "tianjin");
    
16.                   map.put(new Person("dasha",37), "heilongjiang");
    
17.                   
    
18.                   Set<Person> me = map.keySet();
    
19.                   
    
20.                   TreeSet<Person> ts=new TreeSet<Person>(me);
    
21.                   Iterator<Person> it=ts.iterator();
    
22.                  while(it.hasNext())
    
23.                   {
    
24.                           Person p=it.next();
    
25.                           String str=map.get(p);
    
26.                           System.out.println(p+"..."+str);
    
27.                   }
    
28.         }
    
29.         
    
30. }
    
31. 
    
32. class Person  implements  Comparable<Person>{
    
33.         
    
34.         
    
35.         private String name ;
    
36.         private int age;
    
37.         
    
38.         public Person(String name ,int age){
    
39.                
    
40.                   this.name = name;
    
41.                   this.age = age;
    
42.         }
    
43. 
    
44.         public String getName() {
    
45.                 return name;
    
46.         }
    
47. 
    
48.         public void setName(String name) {
    
49.                 this.name = name;
    
50.         }
    
51. 
    
52.         public int getAge() {
    
53.                 return age;
    
54.         }
    
55. 
    
56.         public void setAge(int age) {
    
57.                 this.age = age;
    
58.         }
    
59. 
    
60.         @Override
    
61.         public String toString() {
    
62.                 return "Person [name=" + name + ", age=" + age + "]";
    
63.         }
    
64. 
    
65.         @Override
    
66.         public int hashCode() {    //这里获取的hashcode的值，age*34，只是设置一个值，可以是任意的数，你可以自由支配
    
67.          
    
68.                   return name.hashCode()+age*34;
    
69.         }
    
70.         
    
71. 
    
72.         @Override
    
73.         public boolean equals(Object obj) {
    
74.          
    
75.                  if(!(obj instanceof Person))
    
76.                           throw  new ClassCastException("类型转换异常");
    
77.                
    
78.                        Person p= (Person)  obj;
    
79.                  
    
80.                        return this.name.equals(p.name) && this.age== p.age;
    
81.                
    
82.         }
    
83. 
    
84.         @Override
    
85.         public int compareTo(Person o) {   // 这个是实现Comparable接口，加入你自己想要比较的内容，自然顺序是abc，123，如果你想颠倒，把返回值颠倒就行了。
    
86.                   int num= new Integer(this.age).compareTo(new Integer(o.age));
    
87.                   
    
88.                    if(num==0)
    
89.                            
    
90.                     return    this.name.compareTo(o.name);
    
91.                
    
92.                 return num;
    
93.         }
    
94. 
    
95. }

复制代码

hashmap不能排序，你要想排序的话，必须自己编写程序进行排序，上面是我的排序

首先我要说的是，楼上各位讲的似乎都有点不太着调，因为首先要存入的是一个HashMap集合，所以person这个类继承comparable后，复不复写compareTo()这个方法都没关系，因为person存入HashMap集合中根本不会调用compareTo()这个方法，而是调用hashCode()方法计算出hash值后进行排序。
   而equals()方法是用来比较两个对象是否相等的，只有在你存入的两个person对象的hash值相同时，才会调用一次equals()方法，如果存入的person对象的hash值都不相同,那么连一次equals()方法都不会调用，你只要记住hashCade()是用来计算hash值的，每个元素存入HashMap中时都会度调用一次它。
   而如果person对象是存入TreeMap集合中的话，那么这时才会调查用compareTo()方法进行比较，而如果你在定义TreeMap时传入了比较器，这个时候就不调用compareTo()方法了，而是优先调用比较器的compare()方法来进行比较。

  说了这么多，希望能帮到你。