大家看看，为什么这两对象的哈兮码竟然相同呀？一个是String对象一个是HashSet对象，这，这是为什么呀？

1. public static void main(String[] args) {
   
2.                 // TODO Auto-generated method stub
   
3.                 String s1=new String("zhangjinyu");
   
4.                 String s2=new String("zhangjinyu");
   
5.                 System.out.println("s1==s2:"+(s1==s2));
   
6.                 System.out.println("s1.equals(s2):"+s1.equals(s2));
   
7.                 System.out.println("s1.hashCode()==s2.hashCode():"+(s1.hashCode()==s2.hashCode()));
   
8.                 System.out.println("s1.hashCode():"+s1.hashCode());// String类重写了hashCode()
   
9.                 System.out.println("s2.hashCode():"+s2.hashCode());
   
10.                 Set hash_set=new HashSet();
    
11.                 hash_set.add(s1);
    
12.                 hash_set.add(s2);
    
13.                 System.out.println(hash_set);
    
14.                 System.out.println("hash_set.hashCode():"+hash_set.hashCode());// hash_set运行的hashCode()是AbstractSet中实现的
    
15.         }

复制代码

运行结果：
s1==s2:false
s1.equals(s2):true
s1.hashCode()==s2.hashCode():true
s1.hashCode():1943454207
s2.hashCode():1943454207
[zhangjinyu]
hash_set.hashCode():1943454207

既然发现一样，你就可以看源码  它们的hashCode()是怎么得到的

1.这两个是不同的对象，为什么hancode却一样呢？因为string里面的hashcode是用字符串值计算出来的，确切的说不是地址值。那么也就是说字符串相同，则hashcode值相同
2.这里面一定要弄清楚，string是object的子类，string覆盖了hashcode的方法，专门用来计算字符串的值
3.如果要判断对象是否相同用 s1==s2就行了！
不知道这样说清楚没？

s1==s2:false
答：用了new 这个词的就是一个单独的对象，这里是两个对象，对象没有相等的（只能说他们的内容相等或地址相等），就好比两个人，他们什么都一样，你能说那是一个人，你也只能说这个人的什么特点相同吧，你这么写string s1 ="sd";String s2="sd";那么s1==s2为true,
s1.equals(s2):true
答：这里比较的是内容，都是zhangjinyu，所以true;

s1.hashCode()==s2.hashCode():true
答：这里比较的是内存地址值，所以相同
s1.hashCode():1943454207
s2.hashCode():1943454207
[zhangjinyu]
答：hashSet集合判断两个对象是否相等，是通过Hashcode()和equals()来判断的，那么这里就可以判断他们是相等的
hash_set.hashCode():1943454207

胥文 发表于 2013-2-22 13:49
s1==s2:false
答：用了new 这个词的就是一个单独的对象，这里是两个对象，对象没有相等的（只能说他们的内 ...

额，我问的是为什么一个是String对象，一个HashSet对象，他们的hashCode()相同

夏振博 发表于 2013-2-22 13:43
既然发现一样，你就可以看源码  它们的hashCode()是怎么得到的

/** HashMap.class **/
final int hash(Object k) {
        int h = 0;
        if (useAltHashing) {
            if (k instanceof String) {
                return sun.misc.Hashing.stringHash32((String) k);
            }
            h = hashSeed;
        }

        h ^= k.hashCode();        // 竟然执行了这里,你看哈，k.hashCode()不就已近和s1的相同了吗，为什么还要后面的算法呢？

        // This function ensures that hashCodes that differ only by
        // constant multiples at each bit position have a bounded
        // number of collisions (approximately 8 at default load factor).
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

我是这么理解的，不知道对不对，作为参考
HashSet
它依赖元素类型hashCode()和equals()来保证唯一性，如果hashCode()相等，再使用equals()比较，如果hashCode()不相等，就不再使用equals()比较。
你存进去的是字符串，字符串重写了hashCode()和equals()， 就是说你的集合里只存进去了一个"zhangjinyu"
HashSet从类 java.util.AbstractSet 继承了hashCode()，它是每个元素hashCode()的叠加，正好你里面只有一个，如果再向集合添加不同元素 它们的hashCode()就不一样了
AbstractSet源码：

1. public int hashCode() {
   
2.         int h = 0;
   
3.         Iterator<E> i = iterator();
   
4.         while (i.hasNext()) {
   
5.             E obj = i.next();
   
6.             if (obj != null)
   
7.                 h += obj.hashCode();
   
8.         }
   
9.         return h;
   
10.     }

复制代码

这是我整理出来的结果，大家要是有兴趣可以看一看：

1. public class TestHashSet {
   
2. 
   
3.         /**
   
4.          * @param args
   
5.          */
   
6.         public static void main(String[] args) {
   
7.                 // TODO Auto-generated method stub
   
8.                 String s1=new String("zhangjinyu");
   
9.                 String s2=new String("zhangjin");
   
10.                 System.out.println("s1==s2:"+(s1==s2));
    
11.                 System.out.println("s1.equals(s2):"+s1.equals(s2));
    
12.                 System.out.println("s1.hashCode()==s2.hashCode():"+(s1.hashCode()==s2.hashCode()));
    
13.                 System.out.println("s1.hashCode():"+s1.hashCode());// String类重写了hashCode()
    
14.                 System.out.println("s2.hashCode():"+s2.hashCode());
    
15.                 Set hash_set=new HashSet();
    
16.                 hash_set.add(s1);
    
17.                 hash_set.add(s2);
    
18.                 System.out.println(hash_set);
    
19.                 System.out.println("hash_set.hashCode():"+hash_set.hashCode());// hash_set运行的hashCode()是AbstractSet中实现的
    
20.         }
    
21. /**
    
22. * 来浅析一下为什么hash_set.hashCode()==s1.hashCode()==s2.hashCode()？
    
23. * 答案： 我改了下s2,发现就不会相等了，原来是这样：HashMap中的hashCode的hash算法与他的每个元素有关，上面之所以相同是因为hash_set中只有一个元素
    
24. * //HashSet.class
    
25. * private transient HashMap<E,Object> map;
    
26. * private static final Object PRESENT = new Object();        // 额，是个常量，并且是final型的，这是jdk为了方便将value设为常量PRESET，因为value是可以重复的。
    
27. * public boolean add(E e) {
    
28.         return map.put(e, PRESENT)==null;        // 所以说，调用一下HashSet的add方法，实际上就是想HashMap中增加一行（key-value）记录;
    
29.     }
    
30.     ** HashMap.class **
    
31.    public V put(K key, V value) {
    
32.         if (key == null)
    
33.             return putForNullKey(value);
    
34.         int hash = hash(key);        // 这里调用hash()方法计算
    
35.         int i = indexFor(hash, table.length);        // 用key的hash码的int值和table的长度（也就是key-value对数）进行“与”计算
    
36.         for (Entry<K,V> e = table[i]; e != null; e = e.next) {
    
37.         // 这个table有讲究，他是transient Entry<K,V>[] table;
    
38.          * 而Entry是实际上真正存放key-value对的地方
    
39.             Object k;
    
40.             if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { // 如果存在相同的对象，则不添加，而是进行替换工作
    
41.                 V oldValue = e.value;
    
42.                 e.value = value;
    
43.                 e.recordAccess(this);
    
44.                 return oldValue;
    
45.             }
    
46.         }
    
47.                 // 添加对象
    
48.         modCount++;
    
49.         addEntry(hash, key, value, i);
    
50.         return null;
    
51.     }
    
52.     ** 计算HashMap中的Key值的hash码 **
    
53.     *hash方法就是我们在数据结构中讲的散列函数。它是经过放进HashSet里面的对象作为key得到hashCode码，在进行散列得到的一个整数。        
    
54.     final int hash(Object k) {
    
55.         int h = 0;
    
56.         if (useAltHashing) {
    
57.             if (k instanceof String) {
    
58.                 return sun.misc.Hashing.stringHash32((String) k);
    
59.             }
    
60.             h = hashSeed;
    
61.         }
    
62. 
    
63.         h ^= k.hashCode();        // k.hashCode()用k对象的hashCode()得到hash码
    
64. 
    
65.         // This function ensures that hashCodes that differ only by
    
66.         // constant multiples at each bit position have a bounded
    
67.         // number of collisions (approximately 8 at default load factor).
    
68.         h ^= (h >>> 20) ^ (h >>> 12);
    
69.         return h ^ (h >>> 7) ^ (h >>> 4);
    
70.     }
    
71.     **** hash_set.hashCode() ****
    
72.     public int hashCode() {        // 这里，说明hash_set.hashCode()的值为hash_set中每个对象的hashCode的和
    
73.         int h = 0;
    
74.         Iterator<E> i = iterator();
    
75.         while (i.hasNext()) {
    
76.             E obj = i.next();
    
77.             if (obj != null)
    
78.                 h += obj.hashCode();
    
79.         }
    
80.         return h;
    
81.     }
    
82. * */
    
83. }

复制代码

首先你要知道你的hash_set集合里只存了一个字符串，因为你定义的两个字符串是相同的：：：s1.equals(s2):true
api文档1：:
其次就是set计算hashcode的方法了
api文档2：：
这就能解释为什么string的hashcode和set的hashcode是相同的了