Java数据结构初学笔记

深入理解数据机构及何时使用它们将对变成工作有极大的帮助。
除基本数据类型和字符串外，数组是Java支持的最简单的数据结构。数组是一系列的数据元素，它们都属于某种基本类型和类。数组被视为单个实体，就像基本数据类型变量一样，但包含多个可被独立存取的元素。需要存储和访问相关信息时，数组很有用。
数组最大的缺点在于，不能改变其大小以存储更多或更少的元素。这意味着您不能向已满的数组中加入新的元素。由于链表和向量没有这种限制，所以可以用这些对象来代替数组。
在Java类库中，Java.util包中有一套数据结构，让您能更灵活地操纵数据。

Java.util包提供的数据结构的功能非常强大，具备众多的功能。这些数据结构包括接口Iterator、Map 以及下述类：Bitset、Vector、Stack、Hashtable 。

接口 Iterator
--------------------------------------------------------------------------------
接口 Iterator<E>
所有已知子接口：
ListIterator<E>
所有已知实现类：
Scanner
--------------------------------------------------------------------------------
public interface Iterator<E>对集合进行迭代的迭代器。迭代器代替了 Java Collections Framework 中的 Enumeration。迭代器与枚举有两点不同： 

迭代器允许调用方利用定义良好的语义在迭代期间从迭代器所指向的集合移除元素。
方法名称得到了改进。
此接口是 Java Collections Framework 的成员。
--------------------------------------------------------------------------------

方法摘要
 boolean hasNext()
          如果仍有元素可以迭代，则返回 true。
 E next()
          返回迭代的下一个元素。
 void remove()
          从迭代器指向的集合中移除迭代器返回的最后一个元素（可选操作）。
--------------------------------------------------------------------------------

接口 Map
--------------------------------------------------------------------------------
接口 Map<K,V>
所有已知子接口：
ConcurrentMap<K,V>, SortedMap<K,V>
所有已知实现类：
AbstractMap, Attributes, ConcurrentHashMap, EnumMap, HashMap, Hashtable, IdentityHashMap, LinkedHashMap, Properties, RenderingHints, TreeMap, UIDefaults, WeakHashMap
--------------------------------------------------------------------------------
public interface Map<K,V>将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射一个值。 

此接口代替 Dictionary 类，后者完全是一个抽象类，而不是一个接口。 

Map 接口提供三种collection 视图，允许以键集、值集合或键-值映射关系集的形式查看某个映射的内容。映射的顺序 定义为迭代器在映射的 collection 视图中返回其元素的顺序。某些映射实现可明确保证其顺序，如 TreeMap 类；某些映射实现则不保证顺序，如 HashMap 类。 

注：将可变对象用作映射键时必须格外小心。当对象是映射中某个键时，如果以影响 equals 比较的方式更改了对象的值，则映射的行为就不是特定的。此项禁止的一个特殊情况是不允许某个映射包含其自身作为键。虽然允许某个映射包含其自身作为值，但建议要格外小心：在这样的映射上将无法再定义 equals 和 hashCode 方法。 

所有通用的映射实现类应该提供两个“标准的”构造方法：一个 void（无参数）构造方法，用于创建空映射，另一个是带有 Map 类型单参数的构造方法，用于创建一个与其参数具有相同键-值映射关系的新映射。实际上，后一个构造方法允许用户复制任意映射，生成所需类的一个等价映射。尽管无法强制执行该建议（因为接口不能包含构造方法），但是 JDK 中所有通用的映射实现都遵从它。 

该接口中包含的“破坏性”方法可修改其所操作的映射，如果此映射不支持该操作，则指定这些方法抛出 UnsupportedOperationException。如果是这样，那么在调用对该映射无效时，这些方法可能，但并不一定抛出 UnsupportedOperationException。例如，如果某个不可修改的映射（其映射关系是“重叠”的）为空，则对该映射调用 putAll(Map) 方法时，可能但并不一定抛出异常。 

某些映射实现对可能包含的键和值有所限制。例如，某些实现禁止空键和空值，而某些实现则对其键的类型有限制。尝试插入不合格的键或值会抛出一个未经检查的异常，通常是 NullPointerException 或 ClassCastException。试图查询是否存在不合格的键或值可能抛出异常，或者只是简单地返回 false；某些实现将表现出前一种行为，而某些实现则表现后一种。较为常见的是，试图对不合格的键或值执行操作且该操作的完成不会导致不合格的元素被插入映射中时，将可能抛出一个异常，也可能操作成功，这取决于实现本身。这样的异常在此接口的规范中标记为“可选”。 

此接口是 Java Collections Framework 的成员。 

Collections Framework 接口中的很多方法是根据 equals 方法定义的。例如，contains(Object key) 方法的规范声明：“当且仅当此映射对于键 k 包含以下映射关系时才返回 true：(key==null ? k==null : key.equals(k))”。不 应将此规范解释为它暗指调用具有非空参数 key 的 Map.containsKey 会导致对任意的键 k 调用 key.equals(k)。可随意对各种实现执行优化，只要避免调用 equals 即可，例如，通过首先比较两个键的哈希码（Object.hashCode() 规范保证哈希码不相等的两个对象不会相等）。较为常见的是，各种 Collections Framework 接口的实现可随意利用基础 Object 方法的指定行为，而不管实现程序认为它是否合适。
--------------------------------------------------------------------------------

嵌套类摘要
static interface Map.Entry<K,V>
          映射项（键-值对）。
  方法摘要
 void clear()
          从此映射中移除所有映射关系（可选操作）。
 boolean containsKey(Object key)
          如果此映射包含指定键的映射关系，则返回 true。
 boolean containsValue(Object value)
          如果此映射为指定值映射一个或多个键，则返回 true。
 Set<Map.Entry<K,V>> entrySet()
          返回此映射中包含的映射关系的 set 视图。
 boolean equals(Object o)
          比较指定的对象与此映射是否相等。
 V get(Object key)
          返回此映射中映射到指定键的值。
 int hashCode()
          返回此映射的哈希码值。
 boolean isEmpty()
          如果此映射未包含键-值映射关系，则返回 true。
 Set<K> keySet()
          返回此映射中包含的键的 set 视图。
 V put(K key, V value)
          将指定的值与此映射中的指定键相关联（可选操作）。
 void putAll(Map<? extends K,? extends V> t)
          从指定映射中将所有映射关系复制到此映射中（可选操作）。
 V remove(Object key)
          如果存在此键的映射关系，则将其从映射中移除（可选操作）。
 int size()
          返回此映射中的键-值映射关系数。
 Collection<V> values()
          返回此映射中包含的值的 collection 视图。
  --------------------------------------------------------------------------------

类 BitSet
--------------------------------------------------------------------------------
类 BitSet
java.lang.Object
  java.util.BitSet
所有已实现的接口：
Serializable, Cloneable

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

public class BitSetextends Objectimplements Cloneable, Serializable此类实现了一个按需增长的位向量。位 set 的每个组件都有一个 boolean 值。用非负的整数将 BitSet 的位编入索引。可以对每个编入索引的位进行测试、设置或者清除。通过逻辑与、逻辑或和逻辑异或操作，可以使用一个 BitSet 修改另一个 BitSet 的内容。

默认情况下，set 中所有位的初始值都是 false。

每个位 set 都有一个当前大小，也就是该位 set 当前所用空间的位数。注意，这个大小与位 set 的实现有关，所以它可能随实现的不同而更改。位 set 的长度与位 set 的逻辑长度有关，并且是与实现无关而定义的。

除非另行说明，否则将 null 参数传递给 BitSet 中的任何方法都将导致 NullPointerException。 在没有外部同步的情况下，多个线程操作一个 BitSet 是不安全的。

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

构造方法摘要
BitSet()
          创建一个新的位 set。
BitSet(int nbits)
          创建一个位 set，它的初始大小足以显式表示索引范围在 0 到 nbits-1 的位。
  方法摘要
 void and(BitSet set)
          对此目标位 set 和参数位 set 执行逻辑与操作。
 void andNot(BitSet set)
          清除此 BitSet 中所有的位，其相应的位在指定的 BitSet 中已设置。
 int cardinality()
          返回此 BitSet 中设置为 true 的位数。
 void clear()
          将此 BitSet 中的所有位设置为 false。
 void clear(int bitIndex)
          将索引指定处的位设置为 false。
 void clear(int fromIndex, int toIndex)
          将指定的 fromIndex（包括）到指定的 toIndex（不包括）范围内的位设置为 false。
 Object clone()
          克隆此 BitSet，生成一个与之相等的新 BitSet。
 boolean equals(Object obj)
          将此对象与指定的对象进行比较。
 void flip(int bitIndex)
          将指定索引处的位设置为其当前值的补码。
 void flip(int fromIndex, int toIndex)
          将指定的 fromIndex（包括）到指定的 toIndex（不包括）范围内的每个位设置为其当前值的补码。
 boolean get(int bitIndex)
          返回指定索引处的位值。
 BitSet get(int fromIndex, int toIndex)
          返回一个新的 BitSet，它由此 BitSet 中从 fromIndex（包括）到 toIndex（不包括）范围内的位组成。
 int hashCode()
          返回此位 set 的哈希码值。
 boolean intersects(BitSet set)
          如果指定的 BitSet 中有设置为 true 的位，并且在此 BitSet 中也将其设置为 true，则返回 ture。
 boolean isEmpty()
          如果此 BitSet 中没有包含任何设置为 true 的位，则返回 ture。
 int length()
          返回此 BitSet 的“逻辑大小”：BitSet 中最高设置位的索引加 1。
 int nextClearBit(int fromIndex)
          返回第一个设置为 false 的位的索引，这发生在指定的起始索引或之后的索引上。
 int nextSetBit(int fromIndex)
          返回第一个设置为 true 的位的索引，这发生在指定的起始索引或之后的索引上。
 void or(BitSet set)
          对此位 set 和位 set 参数执行逻辑或操作。
 void set(int bitIndex)
          将指定索引处的位设置为 true。
 void set(int bitIndex, boolean value)
          将指定索引处的位设置为指定的值。
 void set(int fromIndex, int toIndex)
          将指定的 fromIndex（包括）到指定的 toIndex（不包括）范围内的位设置为 true。
 void set(int fromIndex, int toIndex, boolean value)
          将指定的 fromIndex（包括）到指定的 toIndex（不包括）范围内的位设置为指定的值。
 int size()
          返回此 BitSet 表示位值时实际使用空间的位数。
 String toString()
          返回此位 set 的字符串表示形式。
 void xor(BitSet set)
          对此位 set 和位 set 参数执行逻辑异或操作。
  从类 java.lang.Object 继承的方法
finalize, getClass, notify, notifyAll, wait, wait, wait
--------------------------------------------------------------------------------

类 Vector
--------------------------------------------------------------------------------
类 Vector<E>
java.lang.Object
  java.util.AbstractCollection<E>
      java.util.AbstractList<E>
          java.util.Vector<E>
所有已实现的接口：
Serializable, Cloneable, Iterable<E>, Collection<E>, List<E>, RandomAccess
直接已知子类：
Stack

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

public class Vector<E>extends AbstractList<E>implements List<E>, RandomAccess, Cloneable, SerializableVector 类可以实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。但是，Vector 的大小可以根据需要增大或缩小，以适应创建 Vector 后进行添加或移除项的操作。

每个向量会试图通过维护 capacity 和 capacityIncrement 来优化存储管理。capacity 始终至少应与向量的大小相等；这个值通常比后者大些，因为随着将组件添加到向量中，其存储将按 capacityIncrement 的大小增加存储块。应用程序可以在插入大量组件前增加向量的容量；这样就减少了增加的重分配的量。

从 Java 2 平台 v1.2 开始，已改进此类以实现 List，这样它就成为了 Java 的集合框架的一部分。与新集合的实现不同，Vector 是同步的。

由 Vector 的 iterator 和 listIterator 方法所返回的迭代器是快速失败的：如果在迭代器创建后的任意时间从结构上修改了向量（通过迭代器自身的 remove 或 add 方法之外的任何其他方式），则迭代器将抛出 ConcurrentModificationException。因此，面对并发的修改，迭代器很快就完全失败，而不是冒着在将来不确定的时间任意发生不确定行为的风险。Vector 的 elements 方法返回的 Enumeration 不是 快速失败的。

注意，迭代器的快速失败行为不能得到保证，一般来说，存在不同步的并发修改时，不可能作出任何坚决的保证。快速失败迭代器尽最大努力抛出 ConcurrentModificationException。因此，编写依赖于此异常的程序的方式是错误的，正确做法是：迭代器的快速失败行为应该仅用于检测 bug。

此类是 Java Collections Framework 的成员。

 

从以下版本开始：
JDK1.0
另请参见：
Collection, List, ArrayList, LinkedList, 序列化表格

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

字段摘要
protected  int capacityIncrement
          向量的大小大于其容量时，容量自动增加的量。
protected  int elementCount
          Vector 对象中的有效组件数。
protected  Object[] elementData
          存储向量组件的数组缓冲区。
  从类 java.util.AbstractList 继承的字段
modCount
  构造方法摘要
Vector()
          构造一个空向量，使其内部数据数组的大小为 10，其标准容量增量为零。
Vector(Collection<? extends E> c)
          构造一个包含指定集合中的元素的向量，这些元素按其集合的迭代器返回元素的顺序排列。
Vector(int initialCapacity)
          使用指定的初始容量和等于零的容量增量构造一个空向量。
Vector(int initialCapacity, int capacityIncrement)
          使用指定的初始容量和容量增量构造一个空的向量。
  方法摘要
 boolean add(E o)
          将指定元素追加到此向量的末尾。
 void add(int index, E element)
          在此向量的指定位置插入指定的元素。
 boolean addAll(Collection<? extends E> c)
          将指定 Collection 中的所有元素追加到此向量的末尾，按照指定集合的迭代器所返回的顺序追加这些元素。
 boolean addAll(int index, Collection<? extends E> c)
          在指定位置将指定 Collection 中的所有元素插入到此向量中。
 void addElement(E obj)
          将指定的组件添加到此向量的末尾，将其大小增加 1。
 int capacity()
          返回此向量的当前容量。
 void clear()
          从此向量中移除所有元素。
 Object clone()
          返回向量的一个副本。
 boolean contains(Object elem)
          测试指定的对象是否为此向量中的组件。
 boolean containsAll(Collection<?> c)
          如果此向量包含指定 Collection 中的所有元素，则返回 true。
 void copyInto(Object[] anArray)
          将此向量的组件复制到指定的数组中。
 E elementAt(int index)
          返回指定索引处的组件。
 Enumeration<E> elements()
          返回此向量的组件的枚举。
 void ensureCapacity(int minCapacity)
          增加此向量的容量（如有必要），以确保其至少能够保存最小容量参数指定的组件数。
 boolean equals(Object o)
          比较指定对象与此向量的相等性。
 E firstElement()
          返回此向量的第一个组件（位于索引 0 处的项）。
 E get(int index)
          返回向量中指定位置的元素。
 int hashCode()
          返回此向量的哈希码值。
 int indexOf(Object elem)
          搜索给定参数的第一个匹配项，使用 equals 方法测试相等性。
 int indexOf(Object elem, int index)
          搜索给定参数的第一个匹配项，从 index 处开始搜索，并使用 equals 方法测试其相等性。
 void insertElementAt(E obj, int index)
          将指定对象作为此向量中的组件插入到指定的 index 处。
 boolean isEmpty()
          测试此向量是否不包含组件。
 E lastElement()
          返回此向量的最后一个组件。
 int lastIndexOf(Object elem)
          返回指定的对象在此向量中最后一个匹配项的索引。
 int lastIndexOf(Object elem, int index)
          向后搜索指定的对象，从指定的索引处开始搜索，并返回一个索引。
 E remove(int index)
          移除此向量中指定位置的元素。
 boolean remove(Object o)
          移除此向量中指定元素的第一个匹配项，如果向量不包含该元素，则元素保持不变。
 boolean removeAll(Collection<?> c)
          从此向量中移除包含在指定 Collection 中的所有元素。
 void removeAllElements()
          从此向量中移除全部组件，并将其大小设置为零。
 boolean removeElement(Object obj)
          从此向量中移除变量的第一个（索引最小的）匹配项。
 void removeElementAt(int index)
          删除指定索引处的组件。
protected  void removeRange(int fromIndex, int toIndex)
          从此 List 中移除其索引位于 fromIndex（包括）与 toIndex（不包括）之间的所有元素。
 boolean retainAll(Collection<?> c)
          在此向量中仅保留包含在指定 Collection 中的元素。
 E set(int index, E element)
          用指定的元素替换此向量中指定位置处的元素。
 void setElementAt(E obj, int index)
          将此向量指定 index 处的组件设置为指定的对象。
 void setSize(int newSize)
          设置此向量的大小。
 int size()
          返回此向量中的组件数。
 List<E> subList(int fromIndex, int toIndex)
          返回此 List 的部分视图，元素范围为从 fromIndex（包括）到 toIndex（不包括）。
 Object[] toArray()
          返回一个数组，包含此向量中以正确顺序存放的所有元素。
<T> T[]
 toArray(T[] a)
          返回一个数组，包含此向量中以正确顺序存放的所有元素；返回数组的运行时类型为指定数组的类型。
 String toString()
          返回此向量的字符串表示形式，其中包含每个元素的 String 表示形式。
 void trimToSize()
          对此向量的容量进行微调，使其等于向量的当前大小。
  从类 java.util.AbstractList 继承的方法
iterator, listIterator, listIterator
  从类 java.lang.Object 继承的方法
finalize, getClass, notify, notifyAll, wait, wait, wait
  从接口 java.util.List 继承的方法
iterator, listIterator, listIterator
--------------------------------------------------------------------------------

 

类 Stack
--------------------------------------------------------------------------------
java.lang.Object
  java.util.AbstractCollection<E>
      java.util.AbstractList<E>
          java.util.Vector<E>
              java.util.Stack<E>
所有已实现的接口：
Serializable, Cloneable, Iterable<E>, Collection<E>, List<E>, RandomAccess

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

public class Stack<E>extends Vector<E>Stack 类表示后进先出（LIFO）的对象堆栈。它通过五个操作对类 Vector 进行了扩展 ，允许将向量视为堆栈。它提供了通常的 push 和 pop 操作，以及取栈顶点的 peek 方法、测试堆栈是否为空的 empty 方法、在堆栈中查找项并确定到栈顶距离的 search 方法。

首次创建堆栈时，它不包含数据项。

 

从以下版本开始：
JDK1.0
另请参见：
序列化表格

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

字段摘要
  从类 java.util.Vector 继承的字段
capacityIncrement, elementCount, elementData
  从类 java.util.AbstractList 继承的字段
modCount
  构造方法摘要
Stack()
          创建一个空 Stack。
  方法摘要
 boolean empty()
          测试堆栈是否为空。
 E peek()
          查看栈顶对象而不移除它。
 E pop()
          移除栈顶对象并作为此函数的值返回该对象。
 E push(E item)
          把项压入栈顶。
 int search(Object o)
          返回对象在栈中的位置，以 1 为基数。
  从类 java.util.Vector 继承的方法
add, add, addAll, addAll, addElement, capacity, clear, clone, contains, containsAll, copyInto, elementAt, elements, ensureCapacity, equals, firstElement, get, hashCode, indexOf, indexOf, insertElementAt, isEmpty, lastElement, lastIndexOf, lastIndexOf, remove, remove, removeAll, removeAllElements, removeElement, removeElementAt, removeRange, retainAll, set, setElementAt, setSize, size, subList, toArray, toArray, toString, trimToSize
  从类 java.util.AbstractList 继承的方法
iterator, listIterator, listIterator
  从类 java.lang.Object 继承的方法
finalize, getClass, notify, notifyAll, wait, wait, wait
  从接口 java.util.List 继承的方法
iterator, listIterator, listIterator
--------------------------------------------------------------------------------

类 Hashtable
--------------------------------------------------------------------------------
类 Hashtable<K,V>
java.lang.Object
  java.util.Dictionary<K,V>
      java.util.Hashtable<K,V>
所有已实现的接口：
Serializable, Cloneable, Map<K,V>
直接已知子类：
Properties, UIDefaults

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

public class Hashtable<K,V>extends Dictionary<K,V>implements Map<K,V>, Cloneable, Serializable此类实现一个哈希表，该哈希表将键映射到相应的值。任何非 null 对象都可以用作键或值。

为了成功地在哈希表中存储和检索对象，用作键的对象必须实现 hashCode 方法和 equals 方法。

Hashtable 的实例有两个参数影响其性能：初始容量 和加载因子。容量 是哈希表中桶 的数量，初始容量 就是哈希表创建时的容量。注意，哈希表的状态为 open：在发生“哈希冲突”的情况下，单个桶会存储多个条目，这些条目必须按顺序搜索。加载因子 是对哈希表在其容量自动增加之前可以达到多满的一个尺度。初始容量和加载因子这两个参数只是对该实现的提示。关于何时以及是否调用 rehash 方法的具体细节则依赖于该实现。

通常，默认加载因子(.75)在时间和空间成本上寻求一种折衷。加载因子过高虽然减少了空间开销，但同时也增加了查找某个条目的时间（在大多数 Hashtable 操作中，包括 get 和 put 操作，都反映了这一点）。

初始容量主要控制空间消耗与执行 rehash 操作所需要的时间损耗之间的平衡。如果初始容量大于 Hashtable 所包含的最大条目数除以加载因子，则永远 不会发生 rehash 操作。但是，将初始容量设置太高可能会浪费空间。

如果很多条目要存储在一个 Hashtable 中，那么与根据需要执行自动 rehashing 操作来增大表的容量的做法相比，使用足够大的初始容量创建哈希表或许可以更有效地插入条目。

下面这个示例创建了一个数字的哈希表。它将数字的名称用作键：

     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);
     }
 自 Java 2 平台 v1.2 以来，此类已经改进为可以实现 Map，因此它变成了 Java Collections Framework 的一部分。与新集合的实现不同，Hashtable 是同步的。

由迭代器返回的 Iterator 和由所有 Hashtable 的“collection 视图方法”返回的 Collection 的 listIterator 方法都是快速失败 的：在创建 Iterator 之后，如果从结构上对 Hashtable 进行修改，除非通过 Iterator 自身的移除或添加方法，否则在任何时间以任何方式对其进行修改，Iterator 都将抛出 ConcurrentModificationException。因此，面对并发的修改，Iterator 很快就会完全失败，而不冒在将来某个不确定的时间发生任意不确定行为的风险。由 Hashtable 的键和值方法返回的 Enumeration 不 是快速失败的。

注意，迭代器的快速失败行为无法得到保证，因为一般来说，不可能对是否出现不同步并发修改做出任何硬性保证。快速失败迭代器会尽最大努力抛出 ConcurrentModificationException。因此，为提高这类迭代器的正确性而编写一个依赖于此异常的程序是错误做法：迭代器的快速失败行为应该仅用于检测程序错误。

此类是 Java Collections Framework 的成员。

 

从以下版本开始：
JDK1.0
另请参见：
Object.equals(java.lang.Object), Object.hashCode(), rehash(), Collection, Map, HashMap, TreeMap, 序列化表格

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

构造方法摘要
Hashtable()
          用默认的初始容量 (11) 和加载因子（0.75）构造一个新的空哈希表。
Hashtable(int initialCapacity)
          用指定初始容量和默认的加载因子（0.75）构造一个新的空哈希表。
Hashtable(int initialCapacity, float loadFactor)
          用指定初始容量和指定加载因子构造一个新的空哈希表。
Hashtable(Map<? extends K,? extends V> t)
          构造一个与给定的 Map 具有相同映射关系的新哈希表。
  方法摘要
 void clear()
          将此哈希表清空，使其不包含任何键。
 Object clone()
          创建此哈希表的浅表复制。
 boolean contains(Object value)
          测试此映射表中是否存在与指定值关联的键。
 boolean containsKey(Object key)
          测试指定对象是否为此哈希表中的键。
 boolean containsValue(Object value)
          如果此 Hashtable 将一个或多个键映射到此值，则返回 true。
 Enumeration<V> elements()
          返回此哈希表中的值的枚举。
 Set<Map.Entry<K,V>> entrySet()
          返回此 Hashtable 中所包含的键的 Set 视图。
 boolean equals(Object o)
          按照 Map 接口的定义，比较指定 Object 与此 Map 是否相等。
 V get(Object key)
          返回此哈希表中指定键所映射到的值。
 int hashCode()
          按照 Map 接口的定义，返回此 Map 的哈希码值。
 boolean isEmpty()
          测试此哈希表是否没有键映射到值。
 Enumeration<K> keys()
          返回此哈希表中的键的枚举。
 Set<K> keySet()
          返回此 Hashtable 中所包含的键的 Set 视图。
 V put(K key, V value)
          将指定 key 映射到此哈希表中的指定 value。
 void putAll(Map<? extends K,? extends V> t)
          将指定 Map 的所有映射关系复制到此 Hashtable 中，这些映射关系将替换此 Hashtable 拥有的、针对当前指定 Map 中所有键的所有映射关系。
protected  void rehash()
          增加此哈希表的容量并在内部对其进行重组，以便更有效地容纳和访问其元素。
 V remove(Object key)
          从哈希表中移除该键及其相应的值。
 int size()
          返回此哈希表中的键的数量。
 String toString()
          返回此 Hashtable 对象的字符串表示形式，其形式为 ASCII 字符 ", " （逗号加空格）分隔开的、括在括号中的一组条目。
 Collection<V> values()
          返回此 Hashtable 中所包含值的 Collection 视图。
  从类 java.lang.Object 继承的方法
finalize, getClass, notify, notifyAll, wait, wait, wait
--------------------------------------------------------------------------------