class abc{
        private int a;
        public abc(int i){
                this.a=i;
        }
        public int hashCode(){
                return 1;
        }
        public boolean equals(){
                if(this.a==1)
                {
                return true;}
                else
                        return false;
               
        }
}

...
abc a=new abc(5);          abc b=new abc(1);          abc c=new abc(5);          Collection<abc> c1=new HashSet<abc>();          c1.add(a);          c1.add(b);          c1.add(c);         System.out.println(c1.size());    //打印是3 ，为什么b还能存进去？不是太懂

b是添加不进去的，你现在添加进去了是因为equals(Object o)没有被重写，你这是重载所以会添加进入
还有建议编码风格需要改正，类名大写

hashSet中不能存放两个用equals（重写父类Object类的equals（Object obj））比较相等的值，如果两个对象用equals比较为true则只能放入一个对象，后放入的对象被丢掉而你的程序中没有用equals方法比较相同的两个对象，可以看看我写的小例子如果不懂我再给你讲讲

1. package com.ccit;
   
2. 
   
3. import java.util.Collection;
   
4. import java.util.HashSet;
   
5. 
   
6. public class HashTest {
   
7. 
   
8.         public static void main(String[] args) {
   
9.                 // TODO Auto-generated method stub
   
10.         Collection<People> coll = new HashSet<People>();
    
11.         People p1 = new People("zhou", 22, "男");
    
12.         People p2 = new People("zhan", 25, "女");
    
13.         People p3 = new People("lisi", 26, "男");
    
14.         People p5 = new People("zhou", 28, "女");
    
15.         People p4 = new People("zhou", 22, "男");
    
16.         coll.add(p1);
    
17.         coll.add(p2);
    
18.         coll.add(p3);
    
19.         coll.add(p4);
    
20.         coll.add(p5);
    
21.         System.out.println(coll.size());
    
22.         for(People p : coll)
    
23.         {
    
24.                 System.out.println(p);
    
25.         }
    
26.         }
    
27. 
    
28. }
    
29. 
    
30. class People
    
31. {
    
32.         private String name;
    
33.         private int age;
    
34.         private String sex;
    
35.         
    
36.         public People(String name,int age,String sex)
    
37.         {
    
38.                 this.name = name;
    
39.                 this.age = age;
    
40.                 this.sex = sex;
    
41.         }
    
42. 
    
43.         @Override
    
44.         public boolean equals(Object obj) {
    
45.                 boolean flag = false;
    
46.                 if(obj instanceof People)
    
47.                 {
    
48.                         People p1 = (People)obj;
    
49.                         if(this.hashCode() == p1.hashCode())
    
50.                          flag = true;
    
51.                 }
    
52.                 return flag;
    
53.         }
    
54. 
    
55.         @Override
    
56.         public int hashCode() {
    
57.                 return name.hashCode()+sex.hashCode()+age;
    
58.         }
    
59. 
    
60.         @Override
    
61.         public String toString() {
    
62.                 // TODO Auto-generated method stub
    
63.                 return this.name+"\t"+this.age+"\t"+this.sex;
    
64.         }
    
65.         
    
66.         
    
67. }
    

复制代码

关键就在于你的3个NEW，而且你的EQUALS方法的重写是重点。当集合要添加新的元素时，先调用这个元素的hashCode方法，就一下子能定位到它应该放置的物理位置上。
如果这个位置上没有元素，它就可以直接存储在这个位置上，不用再进行任何比较了；如果这个位置上已经有元素了，
就调用它的equals方法与新元素进行比较，相同的话就不存了，{不相同就散列其它的地址。}，最主要的是：{你的EQUALS方法重写的有问题，比较对象属性是否为1？这里因该用来比较两个对象才对，你这么做就是JVM就默认了两个对象为FALSE了，因为BOOLEAN默认的EQUALS去比较了。相当与你那EQUALS方法是废的，就是这样。}这就是为什么会有3个的原因了。
再清楚点说HASHCODE值只是用来分配存储空间地址和查询用的，主要的判定还是EQUALS。

1. package cn.itcast.day3;
   
2. 
   
3. import java.util.Collection;
   
4. import java.util.HashSet;
   
5. import java.util.Iterator;
   
6. 
   
7. public class hashProblem {
   
8.         public static void main(String[] args){
   
9.         Abc a=new Abc(5);
   
10.         Abc b=new Abc(1);
    
11.         Abc c=new Abc(5);
    
12.         Collection<Abc> c1=new HashSet<Abc>();         
    
13.         c1.add(a);         
    
14.         c1.add(b);         
    
15.         c1.add(c);        
    
16.         Iterator it = c1.iterator();
    
17.         while(it.hasNext()){
    
18.                 Abc abc = (Abc)it.next();
    
19.                 System.out.println("get对象的a值"+abc.getA());
    
20.         }
    
21.         
    
22.         System.out.println(c1.size());  }
    
23. }
    
24. 
    
25. class Abc{
    
26.         private int a;
    
27.         public Abc(int i){
    
28.             this.a=i;
    
29.     }
    
30.         public int  getA()
    
31.         {
    
32.                 return this.a;
    
33.         }
    
34.   
    
35.         public int hashCode(){
    
36.                 return 1;
    
37.         }
    
38.         public boolean equals(Object obj){
    
39.                 Abc ab =(Abc)obj;
    
40.                 if(ab.a==1)
    
41.                 {
    
42.                         return true;
    
43.                 }
    
44.                 else
    
45.                 return false;
    
46.                
    
47.         }
    
48. 
    
49. }

复制代码

我帮你把代码改了下，问题出在equals方法上面 因为你这里用的equal()里面没有写参数，所以没有覆盖Object的方法，所以就不能按照你的方法判断。b写进去的原因是你new了3次，内存创建3次地址空间，这3个对象分别指向3个地址空间，所以肯定不相等，然后就存进去了。

{:soso_e136:}hashCode()中最好不要写固定值返回值，写的固定值的话，挂在同一个单向链表下，数据不能均匀分布也就起不到增删效果了，要均衡分布，最好像这样：a.hashCode()获取当前变量的哈希值来增加元素。
第二个：equals()方法写的有些问题。如下的你可以参考下：

1.         public boolean equals(Object o)
   
2.         {
   
3.                 if(this == o)
   
4.                 {
   
5.                         return true;
   
6.                 }
   
7.                 if(o instanceof abc)
   
8.                 {
   
9.                         abc aABC = (abc)o;
   
10.                         if(aABC.a.equals(this.a))
    
11.                         {
    
12.                                 return true;
    
13.                         }
    
14.                 }               
    
15.                 return false;
    
16.         }

复制代码