hashtable对字符串的碰撞以及源码解析（非常适合新手理解hashtable）

首先我从网上摘抄了三个典型的例子，非常适合来介绍hashtable对字符串的碰撞。

第一个例子，去除字符串数组中中多余的字符串。ps（建议现在还在用eclipse IDE的可以试试IntelliJ IDEA）
代码如下：

import java.util.Enumeration;
import java.util.Hashtable;

public class Main {
    public static void main(String[] args) {
        String[] mobile={"13811071500","13811071500","13811071501","13811071503","13811071501"};
        mobile=checkArray(mobile);
        for(int i=0;i<mobile.length;i++)
            System.out.println(mobile[i]);
    }
    public static String[] checkArray(String[] str){
        Hashtable<String,String> hash = new Hashtable<String, String>();
        for(int i = 0;i < str.length;i++){
            if(!hash.containsKey(str[i])){
                hash.put(str[i],str[i]);
            }
        }
        Enumeration enumeration = hash.keys();
        String[] str_new = new String[hash.size()];
        int i = 0;
        while(enumeration.hasMoreElements()){
            str_new[i] = enumeration.nextElement().toString();
            i++;
        }
        return str_new;
    }
}

输出结果为：

下面是对源码的解析：很多人可以在这里有个困惑，为什么不用Iterator而选择用了Enumeration，我们从hash.keys（）的源码看起

public synchronized Enumeration<K> keys() {
        return this.<K>getEnumeration(KEYS);
    }

可以看到源码返回的类型就是Enmeration类型，所以用Enumeration也不足为奇了。
看代码源代码是一个非常好的习惯和学习方法。
下面我们看看hashtable中containsKey的源码：

 public synchronized boolean containsKey(Object key) {
        Entry<?,?> tab[] = table;
        int hash = key.hashCode();
        int index = (hash & 0x7FFFFFFF) % tab.length;
        for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
            if ((e.hash == hash) && e.key.equals(key)) {
                return true;
            }
        }
        return false;
    }

可以看到这个方法前用了synchronized来修饰，所以你一定会想到hashtable是线程同步安全的。
然后下面的一些代码也很好理解，计算hash值然后进行比对。
第二个例子：

import java.util.Enumeration;
import java.util.Hashtable;

public class Demo2 {
    public static void main(String[] args){
        String[] mobile1={"13811071500","13811071501","13811071502","13811071503","13811071504"};
        String[] mobile2={"13811071500","13811071505","13811071502","13811071506","13811071504"};
        String[] mobile3=compareArray(mobile1,mobile2);
        for(int i=0;i<mobile3.length;i++)
            System.out.println(mobile3[i]);
    }
    public static String[] compareArray(String[]A,String[]B){
        Hashtable<String,String> hash = new Hashtable<String, String>();
        Hashtable<String,String> hash_new = new Hashtable<String, String>();
        for (int i = 0; i < B.length; i++){
            hash.put(B[i],B[i]);
        }
        for (int i = 0 ; i < B.length ; i++) {
            if (!hash.containsKey(A[i])) {
                hash_new.put(A[i], A[i]);
            }
        }
            String[] C = new String[hash_new.size()];
            int j = 0;
            Enumeration enumeration =   hash_new.keys();
            while (enumeration.hasMoreElements()) {
                C[j] = enumeration.nextElement().toString();
                j++;
            }
        return C;
    }
}

运行结果：

可能会有人想好像两个例子的输出结果都是逆序的，实则不然，我们可以回到hashtable表的源码中去看一看就知道了hashtable其实是无序的，逆序输出只不过是表面现象，你多加些数据再试一试就会发现不一样了。
在开发中其实用的更多的就是hashtable，在我们个人学习中可能用hashmap更多一些吧。