Java 之 Hashtable、HashMap 及 Properties

本资源引自：

Java之Hashtable、HashMap及Properties_爱笑的眼睛_新浪博客

http://blog.sina.com.cn/s/blog_6b4f33b20100yjr1.html

-------------------------------------------------------------------------------------------------------------------------------------

Java之Hashtable、HashMap及Properties

 (2011-10-18 17:35:01)

转载▼

标签：  哈希表   hashtable   hashmap   杂谈

分类： Java

文章来源：百度资料http://wenku.baidu.com/view/921383d176eeaeaad1f330f5.html

 1、Hashtable与HashMap的相同之处 

    Java包含两个类，java.util.Hashtable 和java.util.HashMap，它们提供了一个多种用途的hashtable机制。Hashtable和HashMap对象可以让你把一个key和一个value结合起来，并用put() 方法把这对key/value输入到表中。然后你可以通过调用get()方法，把key作为参数来得到这个value（值）。只要满足两个基本的要求，key和value可以是任何对象。注意，因为key和value必须是对象，所以原始类型（primitive types）必须通过运用诸如Integer(int)的方法转换成对象。下面是一段简单的示例代码：

1. 先创建一个hashtable，保存了1, 2, 3三个对象。

Hashtable numbers = new Hashtable();

numbers.put("one", new Integer(1));

numbers.put("two", new Integer(2));

numbers.put("three", new Integer(3));

2. 查找

Integer n = (Integer)numbers.get("two");

if (n != null) {

System.out.println("two = " + n);

}

为了将一个特定类的对象用做一个key，这个类必须提供两个方法，equals() 和 hashCode()。这两个方法在java.lang.Object中，所以所有的类都可以继承这两个方法；但是，这两个方法在Object类中的实现一般没什么用，所以你通常需要自己重载这两个方法。

Equals()方法把它的对象同另一个对象进行比较，如果这两个对象代表相同的信息，则返回true。该方法也查看并确保这两个对象属于相同的类。如果两个参照对象是完全一样的对象，Object.equals()返回true，这就说明了为什么这个方法通常不是很适合的原因。在大多数情况下，你需要一个方法来一个字段一个字段地进行比较，所以我们认为代表相同数据的不同对象是相等的。

hashCode()方法通过运用对象的内容执行一个哈希函数来生成一个int值。Hashtable和HashMap用这个值来算出一对key/value位于哪个bucket（哈希元）（或列表）中。

如果你想创建一个hashtable，这个hashtable运用你自己定义的一个类的对象作为key，那么你应该确信这个类的equals()和hashCode()方法提供有用的值。首先查看你扩展的类，确定它的实现是否满足你的需求。如果没有，你应该重载方法。

任何equals()方法的基本设计约束是，如果传递给它的对象属于同一个类，而且它的数据字段设定为表示同样数据的值，那么它就应该返回true。你也应该确信，如果传递一个空的参数给该方法，那么你的代码返回false：public boolean equals(Object o)

{

if ( (o == null)

|| !(o instanceof myClass))

{

return false;

}

}

 

另外，在设计一个hashCode()方法时，应该记住一些规则。首先，该方法必须为一个特定的对象返回相同的值，而不管这个方法被调用了多少次（当然，只要对象的内容在调用之间没有改变，在将一个对象用做一个hashtable的key时，应该避免这一点）。第二，如果由你的equals()方法定义的两个对象是相等的，那么它们也必须生成相同的哈希码。第三，这更像是一个方针，而不是一个原则，你应该设法设计方法，使它为不同的对象内容生成不同的结果。如果偶尔不同的对象正好生成了相同的哈希码，这也不要紧。但是，如果该方法只能返回范围在1到10的值，那么只能用10个列表，而不管在hashtable中有多少个列表。

String类已经按照要求实现了hashCode()，因为在设计自己的关键字类时，可以调用String.hash()，但是StringBuffer()不能用作关键字类，其并没按要求实现hashCode().

2 、Hashtable和HashMap不同之处：

Hashtable和HashMap类有三个重要的不同之处。第一个不同主要是历史原因。Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现。

也许最重要的不同是Hashtable的方法是同步的，而HashMap的方法不是。这就意味着，虽然你可以不用采取任何特殊的行为就可以在一个多线程的应用程序中用一个Hashtable，但你必须同样地为一个HashMap提供外同步。一个方便的方法就是利用Collections类的静态的synchronizedMap()方法，它创建一个线程安全的Map对象，并把它作为一个封装的对象来返回。这个对象的方法可以让你同步访问潜在的HashMap。这么做的结果就是当你不需要同步时，你不能切断Hashtable中的同步（比如在一个单线程的应用程序中），而且同步增加了很多处理费用。

第三点不同是，只有HashMap可以让你将空值作为一个表的条目的key或value。HashMap中只有一条记录可以是一个空的key，但任意数量的条目可以是空的value。这就是说，如果在表中没有发现搜索键，或者如果发现了搜索键，但它是一个空的值，那么get()将返回null。如果有必要，用containKey()方法来区别这两种情况。

一些资料建议，当需要同步时，用Hashtable，反之用HashMap。但是，因为在需要时，HashMap可以被同步，HashMap的功能比Hashtable的功能更多，而且它不是基于一个陈旧的类的，所以有人认为，在各种情况下，HashMap都优先于Hashtable。

3.Hashtable性能

影响hashtable功效的主要因素就是表中列表的平均长度，因为平均搜索时间与这个平均长度直接相关。很显然，要减小平均长度，你必须增加hashtable中列表的数量；如果列表数量非常大，以至于大多数列表或所有列表只包含一条记录，你就会获得最佳的搜索效率。然而，这样做可能太过分了。如果你的hashtable的列表数远远多于数据条目，那你就没有必要做这样的内存花费了，而在一些情况下，人们也不可能接受这样的做法。

在我们前面的例子中，我们预先知道我们有多少条记录1,000。知道这点后，我们就可以决定我们的hashtable应该包含多少个列表，以便达成搜索速度和内存使用效率之间最好的折中方式。然而，在许多情况下，你预先不知道你要处理多少条记录；数据被读取的文件可能会不断扩大，或者记录的数量可能一天一天地发生很大的变化。

随着条目的增加，Hashtable和HashMap类通过动态地扩展表来处理这个问题。这两个类都有接受表中列表最初数量的构造器，和一个作为参数的负载系数（load factor）：

public Hashtable(int initialCapacity,float loadFactor)

public HashMap(int initialCapacity,float loadFactor)

将这两个数相乘计算出一个临界值。每次给哈希表添加一个新的条目时，计数就被更新，当计数超过临界值时，表被重新设置（rehash)。（列表数量增加到以前数量的两倍加1，所有的条目转移到正确的列表中。）缺省的构造器设定最初的容量为11，负载系数是0.75，所以临界值是8。当第九条记录被添加到表中时，就重新调整哈希表，使其有23个列表，新的临界值将是17（23*0.75的整数部分）。你可以看到，负载系数是哈希表中平均列表数量的上限，这就意味着，在缺省情况下，哈希表很少会有许多包含不只一条记录的列表。比较我们最初的例子，在那个例子中，我们有1,000条记录，分布在10个列表中。如果我们用缺省值，这个表将会扩展到含有1,500多个列表。但你可以控制这点。如果用负载系数相乘的列表数量大于你处理的条目数，那么表永远不会重制，所以我们可以仿效下面的例子：// Table will not rehash until it

// has 1,100 entries (10*110):

Hashtable myHashTable = new Hashtable(10, 110.0F);

你可能不想这么做，除非你没有为空的列表节省内存，而且不介意额外的搜索时间，这可能在嵌入系统中会出现这种情况。然而，这种方法可能很有用，因为重新设置很占用计算时间，而这种方法可以保证永远不会发生重新设置这种情况。

注意，虽然调用put()可以使表增大（列表数量增加），调用remove()不会有相反的结果。所以，如果你有一个大的表，而且从中删除了大部分条目，结果你会有一个大的但是大部分是空的表。

Hashtable测试：

//MyKey.java
class MyKey {
 private String name = null;
 private int age = 0; 
 
 public MyKey(String name, int age)
 {
  this.name=name;
  this.age=age;
 }
 public boolean equals(Object obj) {
  // TODO: Add your code here
  if(obj instanceof MyKey)
  {
   MyKey objTemp=(MyKey)obj;   //编译器不能自动将Object类转换为MyKey
   if(name.equals(objTemp.name))
   {
    return true;
   }
   else
   {
    return false;
   }
    
  }
  else
  {
   return false;
  }
 }

 
 public int hashCode() {
  // TODO: Add your code here
  return name.hashCode()+age;
 }

 
 public String toString() {
  // TODO: Add your code here
  return name+","+age;
 }
 
}

//HashtableTest.java

import java.util.*;
public class HashtableTest {
 
 
 public static void main(String[] args) {
  // TODO: Add your code here
  Hashtable numbers=new Hashtable();
  numbers.put(new MyKey("zhangsan",18),new Integer(1));
  numbers.put(new MyKey("lisi",15),new Integer(2));
      numbers.put(new MyKey("wangwu",20),new Integer(3));  
      
      Enumeration e=numbers.keys();
      while(e.hasMoreElements())
      {
       MyKey key=(MyKey)e.nextElement();
       System.out.print(key.toString()+"=");
       System.out.println(numbers.get(key));
       
      }
      System.out.println(numbers.get(new MyKey("zhangsan",18)));
 } 
}
HashMap测试：

//HsshMapTest.java

import java.util.*;

class HashMapTest

{

        public static void printElements(Collection c,HashMap hm)

        {

                Iterator it=c.iterator();

                while(it.hasNext())

                {

                        Object key1=it.next();

                        System.out.println(key1+" = "+hm.get(key1));

                }

        }

        public static void main(String[] args)

        {

                HashMap hm=new HashMap();

                                

                Student s1=new Student(1,"zhang3");

                Student s2=new Student(2,"li4");

                Student s3=new Student(3,"wang5");

                Student s4=new Student(1,"zhang3");

               

                hm.put(s1,"123");

                hm.put(s2,"456");

                hm.put(s3,"789");

                hm.put(s4,"321");

                Set keys=hm.keySet();

                System.out.println("Key:");

                printElements(keys,hm);                                

        }

}

 

class Student

{

        int num;

        String name;

        Student(int num,String name)

        {

                this.num=num;

                this.name=name;

        }

               

        public int hashCode()

        {

                return num*name.hashCode();

        }

               

        public boolean equals(Object o)

        {

                Student s=(Student)o;

                return num==s.num && name.equals(s.name);

        }

       

        public String toString()

        {

                return num+":"+name;

        }

}

  

4.关于Properties

有时侯，你可能想用一个hashtable来映射key的字符串到value的字符串。DOS、Windows和Unix中的环境字符串就有一些例子，如key的字符串PATH被映射到value的字符串C:WINDOWS;C:WINDOWSSYSTEM。Hashtables是表示这些的一个简单的方法，但Java提供了另外一种方法。

Java.util.Properties类是Hashtable的一个子类，设计用于String keys和values。Properties对象的用法同Hashtable的用法相象，但是类增加了两个节省时间的方法，你应该知道。

Store()方法把一个Properties对象的内容以一种可读的形式保存到一个文件中。Load()方法正好相反，用来读取文件，并设定Properties对象来包含keys和values。

注意，因为Properties扩展了Hashtable，你可以用超类的put()方法来添加不是String对象的keys和values。这是不可取的。另外，如果你将store()用于一个不包含String对象的Properties对象，store()将失败。作为put()和get()的替代，你应该用setProperty()和getProperty()，它们用String参数。

Properties测试：

//PropertiesTest.java

package PropertiesTest;
import java.io.*;
import java.util.Properties;

public class PropertiesTest {
 public static void main(String[] args) {
  // TODO: Add your code here
  Properties settings=new Properties();
  try
  {
   settings.load(new FileInputStream("count.txt"));
  }catch(Exception e)
  {
   //e.printStackTrace();
   settings.setProperty("count",String.valueOf(0));  
  }
  
  //settings.get("count");
  int c=Integer.parseInt(settings.getProperty("count"))+1;//getProperties返回字符串，parseInt()将字符串转换为整数
  System.out.println("This is the "+ c +"st");
  
  //settings.put("count",new Integer(c).toString());
  settings.setProperty("count",new Integer(c).toString());
  try
  {
      settings.store(new FileOutputStream("count.txt"),"Program is used:");
  }catch(Exception e)
  {
   e.printStackTrace();
  }
 } 
}