谁能给详细介绍一下java.util.Hashtable这个类和具体用法吗?谢谢

Question

官方似乎不推荐使用HashTable而用HashMap用法应该一致

Answer 1

用过list,hashmap吗？？基本跟他差不多！
   你就把他当做一个简单的集合来理解就可以了。

Answer 2

HashMap 不是线程安全的，也就是多线程的，所以用起来比较快点。
   HashMap 是java2里边才加近来的，而HashTable是旧的

Answer 3

详细的我也不知道，我只是以前用过一次，平常主要就用put(),get(),containkeys(),clear()这几个方法，put的两个参数一般是key，后面一个是对象（OBJECT），get（key）用前面的key取得对应数据，containkeys（key）判断这个key在hashtable中是否存在，就用过这么多，高手再补充，至于什么线程安全方面的我也想了解，lookup

Answer 4

那如果系统参数都用hashtable来存储的话会不会影响速度呀

Answer 5

所谓线程安全，直观表现是所有方法都是 synchronized 
其方法将在多线程环境下调用时被同步，当然，速度会慢一点。在Java基本类体系中，还有一个例子是Vector，它当初也被设计为线程安全的，即同步的
其功能接近的非同步类是 ArrayList （但愿我没记错，呵呵）
在jdk1.4以后，你有另外一个选择就是LinkedHashMap所有这些依赖于Hash算法的“容器”类，就是用来存放其他 Object 的
存取方法都是提供类似 put(key,value)和value=get(key)方法等等其中，HashTable、HashMap元素对象是无序的
而Vector、ArrayList以及后来的LinkedHashMap更象一个链表，是有序的

Answer 6

java.util.Hashtable实现了Map接口，在Hashtable中使用key对象的hashCode()作为对应的对象的相对存储地址，以便实现根据关键字快速查找对象的功能。所以只有一个实现了hashCode()和equals()方法的对象才可作为Hashtable的key。null值不能作为关键字或值。public class java.util.Hashtable extends Dictionary implements Cloneable, Map, Serializable {      //Hashtable constructors 
     //construct a default Hashtable with default capacity and load of 0.75 
     public Hashtable();                      
     //construct a Hashtable with passed capacity and default load of 0.75  
     public Hashtable (int initialCapacity);  
     //construct Hashtable with passed capacity and load  
     public Hashtable(int initialCapacity, float load);  
     //construct Hashtable with passed mapping  
     public Hashtable(Map);                   
      
     //Hashtable specific methods 
     //checks if Object is in Hashtable  
     public boolean contains(Object);         
     //returns Enumeration of elements in Hashtable  
     public Enumeration elements();           
     //returns Enumeration of keys in hashtable 
     public Enumeration keys();               
     //creates shallow copy of Hashtable(structure copied, but not key/values) 
     public Object clone();                   
     //prints out key/value pairs of Hashtable elements 
     public String toString();                
     //reorganizes all elements in Hashtable, and increases Hashtable capacity  
     protected void rehash();                 
      
     //get Value from passed in key  
     public Object get(Object);               
     //insert key/value pair 
     public Object put(Object key, Object value);       } 
Hashtable是Java 2集合框架推出之前的一个老的工具类，在新的Java 2集合框架下，已经被HashMap取代。Hashtable和HashMap的区别主要是前者是同步的，后者是快速失败机制保证不会出现多线程并发错误（Fast-Fail）。在初始化一个Hashtable时，可以指定两个参数：初始容量、负荷，这两个参数强烈的影响着Hashtable的性能。容量是指对象的个数，负荷是指散列表中的实际存储的对象个数和容量的比率。如果初始容量太小，那么Hashtable需要不断的扩容并rehash()，而这是很耗时的；如果初始容量太大，又会造成空间的浪费。负荷则相反，负荷太小会造成空间浪费，负荷太大又会耗时（因为这会造成较多的关键字的散列码重复，Hashtable使用一个链接表来存储这些重复散列码的对象）。容量的缺省值是11，负荷的缺省值是0.75，一般情况下你都可以使用缺省值来生成一个Hashtable。另外，在Hashtable中的大部分的方法都是同步的。

Answer 7

补充
所谓同步的类速度慢，是指在单线程中使用是，做了多余的 synchronize 操作；
性能影响要看元素个数
存放几个配置参数，用哪个都一样
要是存放成千上万的数据量的话，选择要慎重
对了，存放配置参数更好的选择是Property类，它有良好的文件和流I/O处理例程

Answer 8

类 java.util.Hashtable 
java.lang.Object
   |
   +----java.util.Dictionary
           |
           +----java.util.Hashtable
--------------------------------------------------------------------------------public class Hashtable 
extends Dictionary 
implements Cloneable, Serializable 
下列类的父类： 
Properties 
该类实现了一个散列表，它把键映射到值。任何非 null 的对象可用作键或值。 为成功地从散列表中存储和检索对象，用作键的对象必须执行 hashCode 方法和 equals 方法。 一个 Hashtable 的实例有两个参数影响它的效率：它的容量和加载因数。 加载因数应介于 0.0 和 1.0 之间。当散列表的入口数超过加载因数和当前容量的乘积，容量通过调用 rehash 方法增加。更大的加载因数可使得更有效地使用存储器，但这是以每个查找用更大的期望时间为代价的。 如果在 Hashtable 中制造许多入口，对插入操作来说，用一个足够大的容量创建它比让它执行按表生成时所需的自动再散列更有效。 该例子创建了一个数的散列表。它使用数的名字作为键： 
     Hashtable numbers = new Hashtable();
     numbers.put("one", new Integer(1));
     numbers.put("two", new Integer(2));
     numbers.put("three", new Integer(3));
 
为了检索一个数，使用下列代码： 
     Integer n = (Integer)numbers.get("two");
     if (n != null) {
         System.out.println("two = " + n);
     }
 来自： 
JDK1.0 
参见： 
equals, hashCode, rehash --------------------------------------------------------------------------------构造子索引 
Hashtable() 
用缺省的容量和加载因数构造一个新的空散列表。 
Hashtable(int) 
用指定的初始的容量和缺省的加载因数构造一个新的空散列表。 
Hashtable(int, float) 
用指定的初始的容量和指定的加载因数构造一个新的空散列表。 --------------------------------------------------------------------------------方法索引 
clear() 
清除该散列表使它不包含键。 
clone() 
创建该散列表的影子复制。 
contains(Object) 
检测在该散列表中某些键是否映射到指定值。 
containsKey(Object) 
检测指定的对象是否是该散列表中的一个键。 
elements() 
返回该散列表中的值的一个枚举。 
get(Object) 
返回指定的键在这个散列表中的映射值。 
isEmpty() 
检测是否散列表没有把键映射到值。 
keys() 
返回该散列表中的一个键枚举。 
put(Object, Object) 
在该散列表中映射指定的 键 到指定的 值 。 
rehash() 
把散列表再散列到更大容量的散列表中。 
remove(Object) 
从该散列表中删除键(和它的相应值)。 
size() 
返回该散列表中的键数。 
toString() 
返回该散列表的一个相当长的字符串表示。 --------------------------------------------------------------------------------构造子
Hashtable 
 public Hashtable(int initialCapacity,
                  float loadFactor)用指定的初始容量和指定的加载因数构造一个新的空散列表。 参数： 
initialCapacity - 散列表的初始容量。 
loadFactor - 0.0 和 1.0 之间的一个数。 
抛出： IllegalArgumentException 
如果初始容量小于或等于零，或者加载因数小于或等于零。 
Hashtable 
 public Hashtable(int initialCapacity)用指定的初始容量和缺省的加载因数构造一个新的空散列表。 参数： 
initialCapacity - 散列表的初始容量。 
Hashtable 
 public Hashtable()用缺省的容量和加载因数构造一个新的空散列表。 
--------------------------------------------------------------------------------方法 
size 
 public int size()返回该散列表中的键数。 返回值： 
该散列表中的键数。 
覆盖： 
类 Dictionary 中的 size 
isEmpty 
 public boolean isEmpty()检测是否散列表没有把键映射到值。 返回值： 
为 true ，如果该散列表没有把键映射到值；反之为 false 。 
覆盖： 
类 Dictionary 中的 isEmpty 
keys 
 public synchronized Enumeration keys()返回该散列表中的一个键枚举。 返回值： 
该散列表中的一个键枚举。 
覆盖： 
类 Dictionary 中的 keys 
参见： 
Enumeration, elements 
elements 
 public synchronized Enumeration elements()返回该散列表中的值的一个枚举。 在返回的对象上使用 Enumeration 方法顺次地或取元素。 返回值： 
该散列表中的一个值枚举。 
覆盖： 
类 Dictionary 中的 elements 
参见： 
Enumeration, keys 
contains 
 public synchronized boolean contains(Object value)检测在该散列表中某些键是否映射到指定值。 该操作比 containsKey 方法代价更大。 参数： 
value - 查找的值。 
返回值： 
为 true ，如果某些键映射到该散列表中的值 参数；反之为 false。 
抛出： NullPointerException 
如果值为 null。 
参见： 
containsKey 
containsKey 
 public synchronized boolean containsKey(Object key)检测指定的对象是否是该散列表中的一个键。 参数： 
key - 可能的键。 
返回值： 
为 true ，如果指定的对象是该散列表中的一个键；反之为 false 。 
参见： 
contains 
get 
 public synchronized Object get(Object key)返回指定的键在这个散列表中的映射值。 参数： 
key - 在该散列表中的一个键。 
返回值： 
该键在散列表中的映射值；如果键没有映射到任何值，则返回 null 。 
覆盖： 
类 Dictionary 中的 get 
参见： 
put 
rehash 
 protected void rehash()把散列表再映射到更大容量的散列表中。 该方法在散列表中的键数超过该散列表的容量和加载因数时自动地调用。 put 
 public synchronized Object put(Object key,
                      Object value)在该散列表中映射指定的 键 到指定的 值 。 键和值都不能为 null。 
可通过调用 get 方法用与原始键相等的键来检索值。 
参数： 
key - 散列表键。 
value - 值。 
返回值： 
该散列表中的指定键的先前的值，如果它没有值时返回 null 。 
抛出： NullPointerException 
如果键或值为 null。 
覆盖： 
类 Dictionary 中的 put 
参见： 
equals, get 
remove 
 public synchronized Object remove(Object key)从该散列表中删除键(和它的相应值)。如果键不在散列表中，则该方法什么都不做。 参数： 
key - 需要删除的键。 
返回值： 
该键在散列表中的映射值；如果键没有映射，则返回 null 。 
覆盖： 
类 Dictionary 中的 remove 
clear 
 public synchronized void clear()清除该散列表使它不包含键。 clone 
 public synchronized Object clone()创建该散列表的影子复制。 键和值本身不复制。这是一个代价高昂的操作。 返回值： 
散列表的 clone 。 
覆盖： 
类 Object 中的 clone 
toString 
 public synchronized String toString()返回该散列表的一个相当长的字符串表示。 返回值： 
该散列表的字符串表示。 
覆盖： 
类 Object 中的 toString