class A
{
int count;
public A(){};
public A(int count)
{
  this.count=count;
}
public String toString()
{
  return this.count+"";
}
public boolean equals(Object obj)
{
  if(this==obj)
  {
   return true;
  }
  if(obj!=null&&obj.getClass()==A.class)
  {
   A a=(A)obj;
   if(this.count==a.count)
   {
    return true;
   }
  }
  return false;
}
public int hashCode()
{
  return (int)this.count;
}
}
public class TestHashSet
{
public static void main(String[]args)
{
  A Second=new A();
  HashSet hs=new HashSet();

  hs.add(new A(1));
  hs.add(new A(2));
  hs.add(new A(3));
  System.out.println("输出的集合元素为->"+hs);       //①这里输出 1,2,3
  Iterator it=hs.iterator();         //迭代集合元素
  A first=(A)it.next();            //迭代第一个元素
  first.count=2;                     
  A second=(A)it.next();           
  System.out.println("输出的集合元素为->"+hs); //②这里输出2,2,3
  /*
         先比较②中第一个元素和②中第二个元素的equals和hashCode()
  */
          System.out.println("first和second是一个对象吗？"+first.equals(second)); //③返回true,表示是一个对象
   
    System.out.print("first和second的hashCode相等吗？----->");
    System.out.print(((int)(first.count))==((int)(second.count)));//④返回true，表示在一个位置保存

    /*
为什么④处的hashCode是相等的？我的理解应该是②中的第一个元素hashCode==①中第一个元素，
     还有②中第一个元素的hashCode!=②中第二个元素。否则只能出现一个元素，可是现实 ②处输出了2,2,3
     则表示②中的第一个元素和②中第二个元素有不同的hashCode值，可是为什么我④处比较后都是相等的呢？？返回true..
     这是为什么？？？？

1. import java.util.HashSet;
   
2. import java.util.Iterator;
   
3. 
   
4. class A {
   
5.         int count;
   
6. 
   
7.         public A() {
   
8.         };
   
9. 
   
10.         public A(int count) {
    
11.                 this.count = count;
    
12.         }
    
13. 
    
14.         public String toString() {
    
15.                 return this.count + "";
    
16.         }
    
17. 
    
18.         public boolean equals(Object obj) {
    
19.                 if (this == obj) {
    
20.                         return true;
    
21.                 }
    
22.                 if (obj != null && obj.getClass() == A.class) {
    
23.                         A a = (A) obj;
    
24.                         if (this.count == a.count) {
    
25.                                 return true;
    
26.                         }
    
27.                 }
    
28.                 return false;
    
29.         }
    
30. 
    
31.         public int hashCode() {
    
32.                 return (int) this.count;
    
33.         }
    
34. }
    
35. 
    
36. public class TestHashSet {
    
37.         public static void main(String[] args) {
    
38.                 A Second = new A();
    
39.                 HashSet hs = new HashSet();
    
40. 
    
41.                 hs.add(new A(1));
    
42.                 hs.add(new A(2));
    
43.                 hs.add(new A(3));
    
44.                 System.out.println("输出的集合元素为->" + hs); // ①这里输出 1,2,3
    
45.                 Iterator it = hs.iterator(); // 迭代集合元素
    
46.                 A first = (A) it.next(); // 迭代第一个元素
    
47.                 first.count = 2;
    
48.                 A second = (A) it.next();
    
49.                 System.out.println("输出的集合元素为->" + hs); // ②这里输出2,2,3
    
50.                
    
51.                
    
52.                 System.out.println("first和second是一个对象吗？"+ (first == second)); //③返回false,表示不是一个对象
    
53.                 System.out.println("first和second是相等吗？"+first.equals(second)); //③返回true,表示是相等的，相等并不是说一个对象
    
54.                 System.out.print("first和second的hashCode相等吗？----->" + (first.hashCode() == second.hashCode())); //④返回true，表示在hashcod相等,注意此时hashcode是存储以后改变了存的元素的hashcode后的结果
    
55.                
    
56.         }
    
57. }

复制代码

关于hashcode的问题，由于你是令hashcode等于自身的count,所以哪几个对象hashcode相等与否是很明白；
其次这里你要知道，next返回的应该是对象的引用，而不是对象的副本．
开始时你存了三个对象，他们的count都不同，即hashcode也不行，所以都存进去了没有问题；
然后，你调用next返回的first是第一个对象的引用，你又用first.count = 2改变了第一个对象的count也即改变了其hashcode,此时，第一个对象与第二个对象hascode就相同了，都等于他们的count,此时虽然hashcode重复，但已经存储了，不会自动删除hashcode重复的对象

关于hashcode的问题，由于你是令hashcode等于自身的count,所以哪几个对象hashcode相等与否是很明白；
其次这里你要知道，next返回的应该是对象的引用，而不是对象的副本．
开始时你存了三个对象，他们的count都不同，即hashcode也不行，所以都存进去了没有问题；
然后，你调用next返回的first是第一个对象的引用，你又用first.count = 2改变了第一个对象的count也即改变了其hashcode,此时，第一个对象与第二个对象hascode就相同了，都等于他们的count,此时虽然hashcode重复，但已经存储了，不会自动删除hashcode重复的对象