Hashtable与HashMap区别（2）

提到hashtable,先要澄清两个问题hashCode与equals().Hashtable有容量和加载因子,容量相当于桶,因子相当于桶里的对象.而hashCode我们可以把它理解为桶的序号,所以HashCode相同的,即它们在同一个桶里,这两上对象就在同一个桶里,这时候如果他们还equals()的话,那么这两个对象就是一样的.而如果他们的hashCode不一样,即他们不在同一个桶里,那么这两个对象肯定是不一样的.

所以我们在用hashtable进行存储对象时要重写他们的hashCode与equals(),否则会出现很多重复的对象.

hashtable与hashMap最大的区别是,hashtable是方法同步的,而后者是异步的.

先来看看下面的例子吧:

1. public class Ball {
2. private int size;
3. private String name;
4. public Ball(int size, String name) {
5. this.size = size;
6. this.name = name;
7. }
8. public void setSize(int size) {
9. this.size = size;
10. }
11. public int getSize() {
12. return size;
13. }
14. public void setName(String name) {
15. this.name = name;
16. }
17. public String getName() {
18. return name;
19. }
20. public static void main(String[] args) {
21. Hashtable<Ball, String> hash = new Hashtable<Ball, String>();
22. , "one"), "1");
23. , "two"), "2");
24. , "one"), "1");
25. System.out.println(hash.size());
26. }
27. }

可能有的人会认为打印出出来的结果当然是2,有一个是重复的

但结果是3.

因为默认它们都是用Object对象来实现比较的,所以它们的hashCode当然是不一样的

我们可以加以下代码检查是否是这样

1. @Override
2. public int hashCode() {
3. System.out.println(super.hashCode());
4. return super.hashCode();
5. }

那么,如何才能去掉重复的对象的

这里我们必须重写hashCode,如下,我们可以把size相同的对象放入同一个桶里,再比较他们的name

把hashCode方法改为

1. @Override
2. public int hashCode() {
3. System.out.println(size);
4. return size;
5. }
6. 写equals();

1. <pre class="java" name="code">    @Override
2. public boolean equals(Object obj) {
3. if (obj instanceof Ball) {
4. Ball ball = (Ball) obj;
5. return name.equals(ball.getName());
6. }
7. return false;
8. }</pre>

再试试,结果就是为2.

hashtable再每添加一个对象的都会先判断他们的hashCode是否一样,如果一样再判断他们是否equals(),如果返回为true的话,那么这个对象将不添加

我们也可以看一下源代码实现

1. /**
2. * Maps the specified <code>key</code> to the specified
3. * <code>value</code> in this hashtable. Neither the key nor the
4. * value can be <code>null</code>. <p>
5. *
6. * The value can be retrieved by calling the <code>get</code> method
7. * with a key that is equal to the original key.
8. *
9. * @param      key     the hashtable key
10. * @param      value   the value
11. * @return     the previous value of the specified key in this hashtable,
12. *             or <code>null</code> if it did not have one
13. * @exception  NullPointerException  if the key or value is
14. *               <code>null</code>
15. * @see     Object#equals(Object)
16. * @see     #get(Object)
17. */
18. public synchronized V put(K key, V value) {
19. // Make sure the value is not null
20. if (value == null) {
21. throw new NullPointerException();
22. }
23. // Makes sure the key is not already in the hashtable.
24. Entry tab[] = table;
25. int hash = key.hashCode();
26. int index = (hash & 0x7FFFFFFF) % tab.length;
27. for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
28. if ((e.hash == hash) && e.key.equals(key)) {
29. V old = e.value;
30. e.value = value;
31. return old;//这里如果比较结果相同时就返回原来的值
32. }
33. }
34. modCount++;
35. if (count >= threshold) {
36. // Rehash the table if the threshold is exceeded
37. rehash();
38. tab = table;
39. index = (hash & 0x7FFFFFFF) % tab.length;
40. }
41. // Creates the new entry.
42. Entry<K,V> e = tab[index];
43. tab[index] = new Entry<K,V>(hash, key, value, e);
44. count++;
45. return null;
46. }

hashMap允许键与值为空.其他的和hashtable是一样的.

具体可再参考API...