1. <p>import java.util.*;
   
2. class Student implements Comparable<Student>
   
3. //implements Comparable<Student> 是为了防止Student存入二叉树中 使其具备可序的要实现Comparable
   
4. {
   
5. private String name;
   
6. private int age;
   
7. Student(String name,int age)
   
8. {
   
9.   this.name=name;
   
10.   this.age=age;
    
11. }
    
12. public int compareTo(Student s)//（Student）如存入二叉树让Student可序
    
13. {
    
14.   int num=new Integer(this.age).compareTo(new Integer(s.age));
    
15.   if(num==0)
    
16.    return this.name.compareTo(s.name);
    
17.   return num;
    
18. }
    
19. public int hashCode()
    
20. {
    
21.   return name.hashCode()+age*34;
    
22. }
    
23. public boolean equals(Object obj)//保证元素（学生）的唯一性
    
24. {
    
25.   if(!(obj instanceof Student))
    
26.     throw new ClassCastException("类型不匹配");
    
27.   Student s=(Student)obj;
    
28.   return this.name.equals(s.name) && this.age==s.age;
    
29. }
    
30. public String getName()
    
31. {
    
32.   return name;
    
33. }
    
34. public int getAge()
    
35. {
    
36.   return age;
    
37. }
    
38. public String toString()
    
39. {
    
40.   return name+":"+age;
    
41. }
    
42. }</p>
    
43. <p> </p>

复制代码

毕老师的课件创建一个学生类
我想问下
public int hashCode()
{
  return name.hashCode()+age*34;
}
public boolean equals(Object obj)//保证元素（学生）的唯一性
{
  if(!(obj instanceof Student))
    throw new ClassCastException("类型不匹配");
  Student s=(Student)obj;
  return this.name.equals(s.name) && this.age==s.age;
}
这里面的
public int hashCode()
{
  return name.hashCode()+age*34;
}
问题一 这个函数的目的是什么 ？
问题二 return name.hashCode()+age*34;这个又表示什么呢？搞不明白了   还有这个age*34;？

1 这个函数是复写hashCode()
2,表示是以name的hashCode来代替原来的hashCode,age*34只是为了使hashCode()更不容易出现重复。所以你这两个问题其实就是一个问题

gudao20080 发表于 2013-8-14 18:08
1 这个函数是复写hashCode()
2,表示是以name的hashCode来代替原来的hashCode,age*34只是为了使hashCode()更 ...

那hashCode()就可以看做原来存在的键对吗？

李健09 发表于 2013-8-15 10:03
那hashCode()就可以看做原来存在的键对吗？

hashCode()复写之后，你就可以自己设定判断键是否唯一的标准，比如说一个Person类，有name和age属性，你是认为名字相同是同一个人呢，还是年龄相同是同一个人？这里就可以通过返回name或age的hashCode来自己定义标准，不再使用默认的判断标准

看到了这一题，我想到了我写过的一个差不多的代码

1. package cn.itcase;
   
2. 
   
3. class Person implements Comparable {
   
4.         private String name;
   
5.        
   
6.         public String getName() {
   
7.                 return name;
   
8.         }
   
9.         public void setName(String name) {
   
10.                 this.name = name;
    
11.         }
    
12.        
    
13.         private int ID;
    
14.        
    
15.         public int getID() {
    
16.                 return ID;
    
17.         }
    
18.         public void setID(int ID) {
    
19.                 this.ID = ID;
    
20.         }
    
21.         public String toString(){
    
22.                 return name + ";" + ID;
    
23.         }
    
24.        
    
25.         public Person(String name, int ID){
    
26.                 super();
    
27.                 this.name = name;
    
28.                 this.ID = ID;
    
29.         }
    
30.        
    
31.         public Person(){
    
32.                 super();
    
33.         }
    
34.         @Override
    
35.         public boolean equals(Object obj) {
    
36.                 // TODO Auto-generated method stub
    
37.                 Person p = (Person)obj;
    
38.                 return this.name.equals(p.name) && this.ID == p.ID;
    
39.         }
    
40.         @Override
    
41.         public int hashCode() {
    
42.                 // TODO Auto-generated method stub
    
43.                 int num = 38;
    
44.                 return this.name.hashCode() + ID*num;
    
45.         }
    
46.         @Override
    
47.         public int compareTo(Object o) {
    
48.                 // TODO Auto-generated method stub
    
49.                 Person p = (Person)o;
    
50.                 if (this.ID > p.ID) {
    
51.                         return 1;
    
52.                 }else if(this.ID < p.ID){
    
53.                         return -1;
    
54.                 }else {
    
55.                         return this.name.compareTo(p.name);
    
56.                 }
    
57.         }
    
58.        
    
59.        
    
60.                
    
61.        
    
62. }

复制代码

其中关于hashCode()方法的复写是为了避免哈希值出现重复导致错误的结果，而且，所乘以的数字越大，出现错误的几率越小

谢了各位