HashSet集合在判断集合元素是否存在时，为什么需要通过元素的两个方法hashCode和equals来实现？能不能只用其中一种方法？还有，下面这个hashCode方法:
                public int hashCode()
        {
            return name.hashCode()+age*46;//这里age*46是什么意思？
        }

hashSet里边会有一个默认的比较方法，判断hashSet中元素是否相同  通过hashCode 和equals方法来比较
先比较元素hashCode值是不是相同  如果相同  才会判断equals方法是否为true  是的话两元素就相同  不是的话就是不同
是为了保证元素唯一性的。

这个里边  你首先要了解的是  set集合中元素是不可以重复的   如果元素重复了  那么后边的将不会进入集合中 。


这个题中它返回的是name.hashCode()+age*46  简单说就是一个数  如果直接是name.hashCode()+age这个的话   那么很有可能会出现这样一种情况 name.hashCode()是30 age是10   那么他们的和是40   而这时另一个元素中  name.hashCode()是10  age是30  那么另一元素的和也是40   这样hashCode方法就判断两元素相同 回去用equals方法比较   效率较低  所以可以让age*46  这样他们的和算的时候相同的几率就比较小   很少会用到equals方法去比较了  这样效率较高  乘号后边可以是任意的一个数  关键不在这个数是几的问题  而是说乘以一个数  很大可能会让他们通过hashCode方法直接就比较出来是不是相同

1. package Test;
   
2. 
   
3. import java.util.HashSet;
   
4. 
   
5. class Person
   
6. {
   
7.         private String name;
   
8.         private int age;
   
9.         Person(String name,int age)
   
10.         {
    
11.                 this.name = name;
    
12.                 this.age = age;
    
13.         }
    
14.        
    
15.         public int hashCode()
    
16.         {
    
17.                 System.out.println(this.name+"....hashCode");
    
18.                 return name.hashCode()+age*37;
    
19.         }
    
20. 
    
21.         public boolean equals(Object obj)
    
22.         {
    
23. 
    
24.                 if(!(obj instanceof Person))
    
25.                         return false;
    
26. 
    
27.                 Person p = (Person)obj;
    
28.                 System.out.println(this.name+"...equals.."+p.name);
    
29. 
    
30.                 return this.name.equals(p.name) && this.age == p.age;
    
31.         }
    
32. 
    
33.        
    
34.         public String getName()
    
35.         {
    
36.                 return name;
    
37.         }
    
38.         public int getAge()
    
39.         {
    
40.                 return age;
    
41.         }
    
42. }

复制代码

HashSet是Set集合的子类，而在Set体系中必须保证元素是唯一的，这在HashSet集合中就是通过元素的两个方法hashCode和equals来实现的。
此时判断元素的存在性只是间接的，并不是说元素的这两种方法就是为了判断存在性的
而至于name.hashCode()+age*46中*46只是为了减小由于偶然姓名、年龄的选取导致的该hash值相同出现错误判断的机率

往HashSet集合里面存入元素的时候，默认的会首先调用hashCode()方法，去判断所存元素的hash值和集合里面元素的hash值是否相同，若果不相同就把元素存入到集合中，如果相同了就会调用equals方法再进行比较。打个比方说
Student s1 = new Student("zhangsan",25);
Student s2 = new Student("zhangsan",25);
创建了两个学生对象，我们存入的意思是如果姓名和年龄都相同，就是同一个，第二个不往里面存，如果不覆写hashCode()这个方法这两个学生对象往HashSet集合里面存的话，肯定都会存进去的，因为两个学生对象的地址值都不一样。可以看下面的代码

1. import java.util.*;
   
2. public class HashSetDemo {
   
3.         public static void main(String[] args){
   
4.                 HashSet hs = new HashSet();
   
5.                 hs.add(new Student("zhangsan",26));
   
6.                 hs.add(new Student("lisi",25));
   
7.                 hs.add(new Student("wangwu",21));
   
8.                 hs.add(new Student("wangwu",21));
   
9.                 hs.add(new Student("zhangsan",26));
   
10.                 Iterator it = hs.iterator();
    
11.                 while(it.hasNext()){
    
12.                         Student s = (Student)it.next();
    
13.                         System.out.println(s.getName()+".."+s.getAge());
    
14.                 }                       
    
15.         }
    
16. }
    
17. class Student{
    
18.         private String name;
    
19.         private int age;
    
20.         Student(String name,int age){
    
21.                 this.name = name;
    
22.                 this.age = age;
    
23.                
    
24.         }
    
25.         public int hashCode(){
    
26.                 System.out.println("hashCode"+"..."+this.name);
    
27.                 return name.hashCode()+age*21;
    
28.                
    
29.         }
    
30.         public boolean equals(Object obj){
    
31.                 if(!(obj instanceof Student))
    
32.                         return false;
    
33.                 Student s = (Student)obj;
    
34.                 System.out.println(this.name+".."+s.name);
    
35.                 System.out.println(this.age+".."+s.age);
    
36.                 return this.name.equals(s.name)&&this.age==s.age;
    
37.                        
    
38.         }
    
39.         public String getName() {
    
40.                 return name;
    
41.         }
    
42.         public void setName(String name) {
    
43.                 this.name = name;
    
44.         }
    
45.         public int getAge() {
    
46.                 return age;
    
47.         }
    
48.         public void setAge(int age) {
    
49.                 this.age = age;
    
50.         }
    
51. }

复制代码

如果没有覆写hashCode();只覆写equals()方法的话，直接判断完地址值不相同就会把对象都存进去，根本不会再去调用equals()方法。
至于你说的return name.hashCode()+age*46;这里age*46是为了提高效率，使其尽量在hashCode()方法里判断完是否为同一个元素。