JAVA提高十三：Hashtable&Properties深入分析

最近因為一些瑣碎的事情，導致一直沒時間寫博客，正好今天需求開發完的早，所以趁早寫下本文，本文主要學習的是Hashtable的分析，因為上面一篇文章研究的是HashMap,而Hashtable和HashMap之間存在相似處，是面試中經常會問到的一個問題，因此進行下分析；而之所以加上Properties,是因為Hashtable 在實際生活中我們用的並不多，但是它的子類Properties 使用的頻率相對還是不低的，因此也一起介紹下。好了，言歸正傳，接下來開始分析。

一、Hashtable 的定義

我們翻看下源碼中對Hashtable的定義如下：

public class Hashtable<K,V>
    extends Dictionary<K,V>
    implements Map<K,V>, Cloneable, java.io.Serializable {

從中可以看出HashTable繼承Dictionary類，實現Map接口。其中Dictionary類是任何可將鍵映射到相應值的類（如 Hashtable）的抽象父類。每個鍵和每個值都是一個對象。在任何一個 Dictionary 對象中，每個鍵至多與一個值相關聯。Map是"key-value鍵值對"接口。

HashTable采用"拉鏈法"實現哈希表，它定義了幾個重要的參數：table、count、threshold、loadFactor、modCount。table：為一個Entry[]數組類型，Entry代表了“拉鏈”的節點，每一個Entry代表了一個鍵值對，哈希表的"key-value鍵值對"都是存儲在Entry數組中的。

count：HashTable的大小，注意這個大小並不是HashTable的容器大小，而是他所包含Entry鍵值對的數量。
threshold：Hashtable的閾值，用於判斷是否需要調整Hashtable的容量。threshold的值="容量*加載因子"。
loadFactor：加載因子。 modCount：用來實現“fail-fast”機制的（也就是快速失敗）。所謂快速失敗就是在並發集合中，其進行迭代操作時，若有其他線程對其進行結構性的修改，這時迭代器會立馬感知到，並且立即拋出ConcurrentModificationException異常，而不是等到迭代完成之后才告訴你。

Hashtable 和Map 之間關系圖：

Hashtable繼承於Dictionary類，實現了Map接口。Map是"key-value鍵值對"接口，Dictionary是聲明了操作"鍵值對"函數接口的抽象類。

二、構造方法

// 默認構造函數。
public Hashtable() 

// 指定“容量大小”的構造函數
public Hashtable(int initialCapacity) 

// 指定“容量大小”和“加載因子”的構造函數
public Hashtable(int initialCapacity, float loadFactor) 

// 包含“子Map”的構造函數
public Hashtable(Map<? extends K, ? extends V> t)

上述構造方法中，最核心的其實就是第三個，因為無論是無參構造還是初始化容量構造最后都是調用的第三個，因此有必要看下第三個方法的源碼：

public Hashtable(int initialCapacity, float loadFactor) 
{
         //驗證初始容量
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        //驗證加載因子
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal Load: "+loadFactor);

        if (initialCapacity==0)
            initialCapacity = 1;
    this.loadFactor = loadFactor;
//初始化table，獲得大小為initialCapacity的table數組
    table = new Entry[initialCapacity];
        ////計算閥值
    threshold = (int)(initialCapacity * loadFactor);
    }

Hashtable 方法：

synchronized void                clear()
synchronized Object              clone()
             boolean             contains(Object value)
synchronized boolean             containsKey(Object key)
synchronized boolean             containsValue(Object value)
synchronized Enumeration<V>      elements()
synchronized Set<Entry<K, V>>    entrySet()
synchronized boolean             equals(Object object)
synchronized V                   get(Object key)
synchronized int                 hashCode()
synchronized boolean             isEmpty()
synchronized Set<K>              keySet()
synchronized Enumeration<K>      keys()
synchronized V                   put(K key, V value)
synchronized void                putAll(Map<? extends K, ? extends V> map)
synchronized V                   remove(Object key)
synchronized int                 size()
synchronized String              toString()
synchronized Collection<V>       values()

三、主要方法分析

HashTable的API對外提供了許多方法，這些方法能夠很好幫助我們操作HashTable【如上所示】，但是這里主要介紹的是兩個最根本的方法：put、get。

首先我們先看put方法：將指定 key 映射到此哈希表中的指定 value。注意這里鍵key和值value都不可為空。

public synchronized V put(K key, V value) {
        // 確保value不為null
        if (value == null) {
            throw new NullPointerException();
        }

        /*
         * 確保key在table[]是不重復的
         * 處理過程：
         * 1、計算key的hash值，確認在table[]中的索引位置
         * 2、迭代index索引位置，如果該位置處的鏈表中存在一個一樣的key，則替換其value，返回舊值
         */
        Entry tab[] = table;
        int hash = hash(key);    //計算key的hash值
        int index = (hash & 0x7FFFFFFF) % tab.length;     ////迭代，尋找該key，替換
        for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
            if ((e.hash == hash) && e.key.equals(key)) {
                V old = e.value;
                e.value = value;
                return old;
            }
        }

        modCount++;
        if (count >= threshold) {  //如果容器中的元素數量已經達到閥值，則進行擴容操作
            rehash();
            tab = table;
            hash = hash(key);
            index = (hash & 0x7FFFFFFF) % tab.length;
        }

        // 在索引位置處插入一個新的節點
        Entry<K,V> e = tab[index];
        tab[index] = new Entry<>(hash, key, value, e);
        //容器中元素+1
        count++;
        return null;
    }

put方法的整個處理流程是：計算key的hash值，根據hash值獲得key在table數組中的索引位置，然后迭代該key處的Entry鏈表，若該鏈表中存在一個這個的key對象，那么就直接替換其value值即可，否則在將改key-value節點插入該index索引位置處。如下：假設我們現在Hashtable的容量為5，已經存在了(5,5)，(13,13)，(16,16)，(17,17)，(21,21)這 5 個鍵值對，目前他們在Hashtable中的位置如下：

現在，我們插入一個新的鍵值對，put(16,22)，假設key=16的索引為1.但現在索引1的位置有兩個Entry了，所以程序會對鏈表進行迭代。迭代的過程中，發現其中有一個Entry的key和我們要插入的鍵值對的key相同，所以現在會做的工作就是將newValue=22替換oldValue=16，然后返回oldValue=16.

然后我們現在再插入一個，put(33,33)，key=33的索引為3，並且在鏈表中也不存在key=33的Entry，所以將該節點插入鏈表的第一個位置。

在HashTabled的put方法中有兩個地方需要注意：

 1、HashTable的擴容操作，在put方法中，如果需要向table[]中添加Entry元素，會首先進行容量校驗，如果容量已經達到了閥值，HashTable就會進行擴容處理rehash()，如下:

protected void rehash() {
        int oldCapacity = table.length;
        //元素
        Entry<K,V>[] oldMap = table;

        //新容量=舊容量 * 2 + 1
        int newCapacity = (oldCapacity << 1) + 1;
        if (newCapacity - MAX_ARRAY_SIZE > 0) {
            if (oldCapacity == MAX_ARRAY_SIZE)
                return;
            newCapacity = MAX_ARRAY_SIZE;
        }

        //新建一個size = newCapacity 的HashTable
        Entry<K,V>[] newMap = new Entry[];

        modCount++;
        //重新計算閥值
        threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
        //重新計算hashSeed
        boolean rehash = initHashSeedAsNeeded(newCapacity);

        table = newMap;
        //將原來的元素拷貝到新的HashTable中
        for (int i = oldCapacity ; i-- > 0 ;) {
            for (Entry<K,V> old = oldMap[i] ; old != null ; ) {
                Entry<K,V> e = old;
                old = old.next;

                if (rehash) {
                    e.hash = hash(e.key);
                }
                int index = (e.hash & 0x7FFFFFFF) % newCapacity;
                e.next = newMap[index];
                newMap[index] = e;
            }
        }
    }

在這個rehash()方法中我們可以看到容量擴大兩倍+1，同時需要將原來HashTable中的元素一一復制到新的HashTable中，這個過程是比較消耗時間的，同時還需要重新計算hashSeed的，畢竟容量已經變了。這里對閥值啰嗦一下：比如初始值11、加載因子默認0.75，那么這個時候閥值threshold=8，當容器中的元素達到8時，HashTable進行一次擴容操作，容量 = 8 * 2 + 1 =17，而閥值threshold=17*0.75 = 13，當容器元素再一次達到閥值時，HashTable還會進行擴容操作，一次類推。

 2、在計算索引位置index時，HashTable進行了一個與運算過程（hash & 0x7FFFFFFF），為什么需要做一步操作，這么做有什么好處？

這是因為在計算hash值得時候可能是負數因此采用了和0X7FFFFFFF相與的操作保證為正數，這個涉及到計算機的二進制數存放正數負數是如何存放的一個邏輯基礎知識，正數很容易，負數的存放是采用負數的絕對值取反得到反碼然后+1 得到補碼然后進行的存放，因此和0X7FFFFFFF相與可保證只改變符號位而不改變其它位。

相關基礎知識可以參考：

負數的二進制表示方法：http://www.360doc.com/content/12/0801/17/6828497_227700914.shtml

Java 8 種數據類型：http://blog.csdn.net/never_cxb/article/details/47204485

Java位運算符及二進制常識：http://blog.csdn.net/coffeelifelau/article/details/52433653

get方法

相比較於 put 方法，get 方法則簡單很多。其過程就是首先通過 hash()方法求得 key 的哈希值，然后根據 hash 值得到 index 索引（上述兩步所用的算法與 put 方法都相同）。然后迭代鏈表，返回匹配的 key 的對應的 value；找不到則返回 null。

public synchronized V get(Object key) {
        Entry tab[] = table;
        int hash = hash(key);
        int index = (hash & 0x7FFFFFFF) % tab.length;
        for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
            if ((e.hash == hash) && e.key.equals(key)) {
                return e.value;
            }
        }
        return null;
    }

 Hashtable 遍歷方式

//1、使用keys()
Enumeration<String> en1 = table.keys();
    while(en1.hasMoreElements()) {
    en1.nextElement();
}

//2、使用elements()
Enumeration<String> en2 = table.elements();
    while(en2.hasMoreElements()) {
    en2.nextElement();
}

//3、使用keySet()
Iterator<String> it1 = table.keySet().iterator();
    while(it1.hasNext()) {
    it1.next();
}

//4、使用entrySet()
Iterator<Entry<String, String>> it2 = table.entrySet().iterator();
    while(it2.hasNext()) {
    it2.next();
}

四、HashTable與HashMap的區別

HashMap和Hashtable都實現了Map接口，但決定用哪一個之前先要弄清楚它們之間的分別。主要的區別有：線程安全性，同步(synchronization)，以及速度。
1.HashMap幾乎可以等價於Hashtable，除了HashMap是非synchronized的，並可以接受null(HashMap可以接受為null的鍵值(key)和值(value)，而Hashtable則不行)。
2.HashMap是非synchronized，而Hashtable是synchronized，這意味着Hashtable是線程安全的，多個線程可以共享一個Hashtable；而如果沒有正確的同步的話，多個線程是不能共享HashMap的。Java 5提供了ConcurrentHashMap，它是HashTable的替代，比HashTable的擴展性更好。
3.另一個區別是HashMap的迭代器(Iterator)是fail-fast迭代器，而Hashtable的enumerator迭代器不是fail-fast的。所以當有其它線程改變了HashMap的結構（增加或者移除元素），將會拋出ConcurrentModificationException，但迭代器本身的remove()方法移除元素則不會拋出ConcurrentModificationException異常。但這並不是一個一定發生的行為，要看JVM。這條同樣也是Enumeration和Iterator的區別。
4.由於Hashtable是線程安全的也是synchronized，所以在單線程環境下它比HashMap要慢。如果你不需要同步，只需要單一線程，那么使用HashMap性能要好過Hashtable。
HashMap不能保證隨着時間的推移Map中的元素次序是不變的。
我們能否讓HashMap同步？
HashMap可以通過下面的語句進行同步：Map m = Collections.synchronizeMap(hashMap);
結論:
Hashtable和HashMap有幾個主要的不同：線程安全以及速度。僅在你需要完全的線程安全的時候使用Hashtable，而如果你使用Java 5或以上的話，請使用ConcurrentHashMap。

 五、Properties分析

java.util
類 Properties
java.lang.Object
  java.util.Dictionary<K,V>
      java.util.Hashtable<Object,Object>
          java.util.Properties

可以看到它是Hashtable的一個子類，是一個使用比父類使用更多的類，Properties類表示了一個持久的屬性集，它是在一個文件中存儲鍵值對兒的，其中鍵值對兒以等號分隔。Properties可保存在流中或從流中加載。屬性列表中的每個鍵及其所對應的值都是字符串。Properties類是線程安全的：多個線程可以共享單個Properties對象而無需進行外部同步。一組屬性示例： 
foo=bar 
fu=baz

一個屬性列表可包含另一個屬性列表作為它的“默認值”；如果未能在原有的屬性列表中搜索到屬性鍵，則搜索第二個屬性列表。
如果在“不安全”的 Properties 對象（即包含非 String 的鍵或值）上調用 store 或 save 方法，則該調用將失敗。類似地，如果在“不安全”的 Properties 對象（即包含非 String 的鍵）上調用 propertyNames 或 list 方法，則該調用將失敗。

除了輸入/輸出流使用 ISO 8859-1 字符編碼外，load(InputStream) / store(OutputStream, String)方法與 load(Reader)/store(Writer, String)對的工作方式完全相同。
loadFromXML(InputStream)和 storeToXML(OutputStream, String, String)方法按簡單的 XML 格式加載和存儲屬性。默認使用 UTF-8 字符編碼，但如果需要，可以指定某種特定的編碼。XML 屬性文檔具有以下 DOCTYPE 聲明：
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
一下列出了Properties的方法摘要，有關每個方法的詳細使用情況，請參看API：
http://www.apihome.cn/api/java/Properties.html

示例練習一：如何裝載屬性文件並列出它當前的一組鍵和值。

思路：傳遞屬性文件的輸入流InputStream給load()方法，會將改屬性文件中的每個鍵值對兒添加到Properties實例中；然后條用list()列出所有屬性或者使用getProperty()獲取單獨的屬性。（注意 list() 方法的輸出中鍵-值對的順序與它們在輸入文件中的順序不一樣。 Properties 類在一個散列表（hashtable，事實上是一個 Hashtable 子類）中儲存一組鍵-值對，所以不能保證順序。 ）

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Properties;

public class PropertiesTest {

    public static void main(String[] args) {
        Properties properties = new Properties();
        try {
            properties.load(new FileInputStream("test.properties"));//加載屬性文件
            properties.list(System.out);//將屬性文件中的鍵值對兒打印到控制台
            properties.getProperty("foo");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

示例練習二：如何裝載XML版本的屬性文件並列出它當前的一組鍵和值。（只有裝載方法有差異，其余完全相同load(),loadFromXML()）

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Properties;

public class PropertiesTest {

    public static void main(String[] args) {
        Properties properties = new Properties();
        try {
            properties.loadFromXML(new FileInputStream("test.xml"));//加載屬性文件
            properties.list(System.out);//將屬性文件中的鍵值對兒打印到控制台
            properties.getProperty("foo");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

示例練習三：如何將文件保存到屬性文件中？

import java.util.*;
import java.io.*;

public class StoreXML {
  public static void main(String args[]) throws Exception {
    Properties prop = new Properties();
    prop.setProperty("one-two", "buckle my shoe");
    prop.setProperty("three-four", "shut the door");
    prop.setProperty("five-six", "pick up sticks");
    prop.setProperty("seven-eight", "lay them straight");
    prop.setProperty("nine-ten", "a big, fat hen");
    prop.storeToXML(new FileOutputStream("test.xml"), "saveXML");//將鍵值對兒保存到XML文件中
prop.store(new FileOutputStream("test.properties"), "saveProperties");//將鍵值對兒保存到普通的屬性文件中
    fos.close();
  }
}

將鍵值對兒保存到XML文件中的輸出結果如下：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
<comment>Rhyme</comment>
<entry key="seven-eight">lay them straight</entry>
<entry key="five-six">pick up sticks</entry>
<entry key="nine-ten">a big, fat hen</entry>
<entry key="three-four">shut the door</entry>
<entry key="one-two">buckle my shoe</entry>
</properties>

將鍵值對兒保存到普通的屬性文件中輸出結果如下：

one-two=buckle my shoe
three-four=shut the door
five-six=pick up sticks
seven-eight=lay them straight
nine-ten=a big, fat hen

注意：從一個XML文件中裝載一組屬性，其DTD文件如下：

<?xml version="1.0" encoding="UTF-8"?>
<!-- DTD for properties -->
<!ELEMENT properties ( comment?, entry* ) >
<!ATTLIST properties version CDATA #FIXED "1.0">
<!ELEMENT comment (#PCDATA) >
<!ELEMENT entry (#PCDATA) >
<!ATTLIST entry key CDATA #REQUIRED>

在外圍 <properties> 標簽中包裝的是一個 <comment> 標簽，后面是任意數量的 <entry>標簽。對每一個 <entry> 標簽，有一個鍵屬性，輸入的內容就是它的值。

注意點：路徑問題，如下：

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;

/**
 * 使用Properties讀取配置文件
 * 資源配置文件:
 * 使用相對與絕對路徑讀取
 * load(InputStream inStream) 
   load(Reader reader) 
   loadFromXML(InputStream in) 
 * @author Administrator
 *
 */
public class Demo03 {

    /**
     * @param args
     * @throws IOException 
     * @throws FileNotFoundException 
     */
    public static void main(String[] args) throws FileNotFoundException, IOException {
        Properties pro=new Properties();
        //讀取 絕對路徑
        //pro.load(new FileReader("e:/others/db.properties"));
        //讀取 相對路徑
        pro.load(new FileReader("src/com/bjsxt/others/pro/db.properties"));
        System.out.println(pro.getProperty("user", "bjsxt"));
    }

}

import java.io.IOException;
import java.util.Properties;

/**
 * 使用類相對路徑讀取配置文件
 *  bin  
 * @author Administrator
 *
 */
public class Demo04 {

    /**
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        Properties pro =new Properties();
        //類相對路徑的 / bin 
        //pro.load(Demo04.class.getResourceAsStream("/com/bjsxt/others/pro/db.properties"));
        //"" bin 
        pro.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("com/bjsxt/others/pro/db.properties"));
        System.out.println(pro.getProperty("user", "bjsxt"));
    }

}

 關於類路徑需要注意一下；舉個例子：

import java.io.FileInputStream;
import java.io.InputStream;
import java.util.Collection;
import java.util.Properties;

 /**
 * 使用配置文件讀取調用者的類
 * 
 * @author jiqinlin
 *
 */
 public class ReflectTest {
    public static void main(String[] args) throws Exception{
        //使用絕對路徑，否則無法讀取config.properties
        //InputStream inStream=new FileInputStream("F:\\android\\test\\src\\com\\ljq\\test\\resource\\config.properties");
        
        //ReflectTest.class.getClassLoader().getResourceAsStream(String path): 默認則是從ClassPath根下獲取，path不能以’/'開頭，最終是由ClassLoader獲取資源。 
        //InputStream inStream = ReflectTest.class.getClassLoader().getResourceAsStream("com/ljq/test/resource/config.properties");
        
        // ReflectTest.class.getResourceAsStream(String path)： path不以’/'開頭時默認是從此類所在的包下取資源，以’/'開頭則是從ClassPath根下獲取。
        //其只是通過path構造一個絕對路徑，最終還是由ClassLoader獲取資源。
        //InputStream inStream = ReflectTest.class.getResourceAsStream("/com/ljq/test/resource/config.properties");
        
        //config.properties配置文件所在目錄是ReflectTest類所在子目錄，才可以；否則報空指針異常
         InputStream inStream = ReflectTest.class.getResourceAsStream("resource/config.properties"); 
        
        Properties props=new Properties();
        props.load(inStream);
        inStream.close();
        
        String className=props.getProperty("className");
        Collection collection=(Collection)Class.forName(className).newInstance();
        collection.add("123");
        System.out.println("size="+collection.size()); //size=1
     }
}

config.properties配置文件

className=java.util.HashSet

getResourceAsStream用法大致有以下幾種：

第一：要加載的文件和.class文件在同一目錄下，例如：com.ljq.test目錄下有類ReflectTest.class,同時有資源文件config.properties 

那么，應該有如下代碼： 
ReflectTest.class.getResourceAsStream("config.properties"); 

第二：在ReflectTest.class目錄的子目錄下，例如：com.ljq.test下有類ReflectTest.class,同時在com.ljq.test.resource目錄下有資源文件config.properties

那么，應該有如下代碼： 
ReflectTest.class.getResourceAsStream("resource/config.properties"); 

第三：不在ReflectTest.class目錄下，也不在子目錄下，例如：com.ljq.test下有類ReflectTest.class ,同時在com.ljq.resource目錄下有資源文件config.properties

那么，應該有如下代碼： 
ReflectTest.class.getResourceAsStream("/com/ljq/resource/config.properties"); 

總結一下，可能只是兩種寫法 

第一：前面有 “/” ，“/”代表了工程的根目錄，例如工程名叫做test，“/”代表了test
ReflectTest.class.getResourceAsStream("/com/ljq/resource/config.properties"); 

第二：前面沒有 “/” ，代表當前類的目錄 
ReflectTest.class.getResourceAsStream("config.properties"); 
ReflectTest.class.getResourceAsStream("resource/config.properties"); 

最后，總結 
getResourceAsStream讀取的文件路徑只局限在工程的源文件夾中，包括在工程src根目錄下，以及類包里面任何位置，但是如果配置文件路徑是在除了源文件夾之外的其他文件夾中時，該方法是用不了的。

Properties獲取數據亂碼解決

1.原因
Properties調用load(InputStream)時，讀取文件時使用的默認編碼為ISO-8859-1；當我們將中文放入到properties文件中，通過getProperty(key)獲取值時，取到得數據是ISO-8859-1格式的，但是ISO-8859-1是不能識別中文的。
2.解決方法
通過getProperty()獲取的數據data既然是ISO-8859-1編碼的，就通過data.getByte(“iso-8859-1”)獲取獲取，使用new String(data.getByte(“iso-8859-1”),”UTF-8”)進行轉換。當然properties文件的編碼類型需要和new String(Byte[],charset)中的第二個參數的編碼類型相同。

 

參考資料：

http://wiki.jikexueyuan.com/project/java-collection

http://blog.csdn.net/chenssy/article/details/22896871

http://www.cnblogs.com/linjiqin