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