JAVA提升十三：Hashtable&Properties深刻分析

時間 2019-12-02

標籤 java 提升十三 hashtable&properties hashtable properties 深刻分析欄目 Java 简体版

原文原文鏈接

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

1、Hashtable 的定義java

咱們翻看下源碼中對Hashtable的定義以下：android

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異常，而不是等到迭代完成以後才告訴你。api

Hashtable 和Map 之間關係圖：數組

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

2、構造方法併發

// 默認構造函數。
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()

3、主要方法分析

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[]是不重複的
         * 處理過程：
         * 一、計算key的hash值，確認在table[]中的索引位置
         * 二、迭代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方法中有兩個地方須要注意：

一、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的，畢竟容量已經變了。這裏對閥值囉嗦一下：好比初始值十一、加載因子默認0.75，那麼這個時候閥值threshold=8，當容器中的元素達到8時，HashTable進行一次擴容操做，容量 = 8 * 2 + 1 =17，而閥值threshold=17*0.75 = 13，當容器元素再一次達到閥值時，HashTable還會進行擴容操做，一次類推。

二、在計算索引位置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 遍歷方式

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

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

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

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

4、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。

5、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