举例说明下

HashSet中判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。上述程序中hs集合每次加入新的元素，底层会自动调用hashCode方法，判断两个对象的地址值是否相同，如果不同则视为不同对象，否则会进一步调用equals方法判断对象内容是否相同。这样就会保证HashSet体系中元素的唯一性。
class Person implements Comparable
{
      private String name;
      private int age;
      Person(String name,int age)
      {
            this.name=name;
            this.age=age;
      }
      public String getName()
      {
            return name;
      }
      public int getAge()
      {
            return age;
      }
      //覆盖父类hashCode算法，按对象条件设定哈希值
      public int hashCode()
      {  

            //检测是否调用hashCode方法，以及何时调用
            System.out.println(this.name+"...hashcode..."+this.name);
            return name.hashCode()+age;
      }
            //比较每个对象中的名字和年龄
      public boolean equals(Object obj)
      {
            if(!(obj instanceof Person))
                 throw new RuntimeException("不是Person对象");
            Person p=(Person)obj;//将Object对象强转成Person
            //检测是否调用equals方法，何时调用
            System.out.println(this.name+"...equals..."+p.name);
            return this.name.equals(p.name) && this.age==p.age;
      }
      public int compareTo(Object obj)
      {
            if(!(obj instanceof Person))
                 throw new RuntimeException("不是Person对象");
            Person p=(Person)obj;
            //检测是否调用compareTo方法，何时调用
            System.out.println(this.name+"...zishengcompareto..."+p.name);
            if(this.age>p.age)
            return 1;
            if(this.age==p.age)
            {  

                 //年龄相同继续比较姓名
                 return this.name.compareTo(p.name);
            }
            return -1;
      }

}
class HashSetTest
{
      public static void hashSet()
      {
            HashSet hs= new HashSet();
            hs.add(new Person("h1",21));
            hs.add(new Person("h2",22));
            hs.add(new Person("h3",23));
            hs.add(new Person("h1",21));
            Iterator it=hs.iterator();
            while(it.hasNext())
            {
                  Person p=(Person)it.next();
                  System.out.println(p.getName()+"::"+p.getAge());
            }
      }
}

自己的理解：当HashSet中放入了两个对象后，默认他们的hashCode都是不一样的，因此不需要调用equals方法就能确定这两个对象不是同一个，但是如果这两个对象的值是一样的，这种判断结果就不符合要求了，因此需要重写hashcode方法，将两个对象的hashcode值设为相同，这样就可以进入equals判断阶段，equals方法是继承自object类的，比较的是对象的地址值，所以判断的结果也必定不同，这又不符合要求了，因此也需要重写equals方法。经过改写以上两个方法，可以完成两个对象的比较，只要两个对象的内容（值）相同，就判断为同一个对象，不得重复存储。哈希表就像一个个桶，每个桶都有一个hashcode，只要元素的hashcode相同，equals如果为false，那么这些元素都挂在这个桶里。
HashSet:判断包含，以及删除，都是依据元素的hashCode方法。当hashCode值相同时，在判断一次equals方法。

示例：

1. import java.util.HashSet;
   
2. import java.util.Iterator;
   
3. class HashSetDemo
   
4. {
   
5.         public static void main(String[] args)
   
6.         {
   
7.                 HashSet hs = new HashSet();
   
8.                 hs.add(new Person("a1",11));
   
9.                 hs.add(new Person("a2",12));
   
10.                 hs.add(new Person("a3",13));
    
11.                 hs.add(new Person("a2",12));
    
12.                 Iterator it = hs.iterator();
    
13.                 while(it.hasNext())
    
14.                 {
    
15.                         Person p = (Person)it.next();
    
16.                         System.out.println (p.getName()+"::"+p.getAge());
    
17.                 }
    
18.         }
    
19. }
    
20. class Person
    
21. {
    
22.         private String name;
    
23.         private int age;
    
24.         Person(String name,int age)
    
25.         {
    
26.                 this.name = name;
    
27.                 this.age = age;
    
28.         }
    
29.         public int hashCode()
    
30.         {
    
31.         System.out.println(this.name+"....hashCode");//保证元素唯一性打印所有对象的哈希值
    
32.                 return name.hashCode()+age*37;
    
33.         }
    
34.         public boolean equals(Object obj)
    
35.         {
    
36.                 if(!(obj instanceof Person))
    
37.                         return false;
    
38.                 Person p = (Person)obj;
    
39.                 System.out.println(this.name+"...equals.."+p.name);
    
40.                 return this.name.equals(p.name) && this.age == p.age;
    
41.         }
    
42.         public String getName()
    
43.         {
    
44.                 return name;
    
45.         }
    
46.         public int getAge()
    
47.         {
    
48.                 return age;
    
49.         }
    
50. }

复制代码

最简单的理解，就是先比较两个比较对象的hascode的值是否一样，然后再比较两个对象的内容是不是一样，在比较的时候要覆盖object类中的hashcode和equals方法，根据自定义规则实现两个对象的比较。从而实现唯一性。