java工具包提供了强大的数据接口；在Java中数据结构主要包括以下几种接口和类

• 枚举（Enumeration）
• 位集合（BitSet）
• 向量（Vector）
• 栈（Stack）
• 字典（Dictionary）
• 哈希表（Hashtabel）
• 属性（Properties）

  枚举（Enumeration）

  Java Enumeration接口

  Enumeration接口中定义了一些方法，通过这些方法可以枚举（一次获取一个）对象集合中的元素
  这种传统接口已被迭代器取代，虽然Enumeration还未被遗弃，但是现代代码中已经被很少使用了；尽管如此，它还是使用在诸如Vector和Properties这些传统类所定义的方法中，除此之外，还用在一些API类，并且在应用程序中也广泛被使用；下表总结了一些Enumeration声明的方法

实例

import java.util.Vector;
import java.util.Enumeration;
public class EnumerationTester {
   public static void main(String args[]) {
      Enumeration<String> days;
      Vector<String> dayNames = new Vector<String>();
      dayNames.add("Sunday");
      dayNames.add("Monday");
      dayNames.add("Tuesday");
      dayNames.add("Wednesday");
      dayNames.add("Thursday");
      dayNames.add("Friday");
      dayNames.add("Saturday");
      days = dayNames.elements();
      while (days.hasMoreElements()){
         System.out.println(days.nextElement()); 
      }
   }
}
//结果为：
Sunday
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday

位集合（BitSet）

Java Bitset类

一个Bitset类创建一种特殊类型的数组来保持位值；BitSet中数组大小会随着需要增加；这和位向量（vector of bits）比较类似。
这是一个传统的类，但它在Java2中被完全重新设计
BitSet定义了两个构造方法。
第一个构造方法创建了一个默认的对象：

BitSet()

第二个方法允许用户指定初始大小，所有位初始化为0

BitSet(int size)

BitSet中实现了Cloneable接口中定义的方法如下表所列：

实例

import java.util.BitSet;
public class BitSetDemo {
  public static void main(String args[]) {
     BitSet bits1 = new BitSet(16);
     BitSet bits2 = new BitSet(16);
     // set some bits
     for(int i=0; i<16; i++) {
        if((i%2) == 0) bits1.set(i);
        if((i%5) != 0) bits2.set(i);
     }
     System.out.println("Initial pattern in bits1: ");
     System.out.println(bits1);
     System.out.println("\nInitial pattern in bits2: ");
     System.out.println(bits2);
     // AND bits
     bits2.and(bits1);
     System.out.println("\nbits2 AND bits1: ");
     System.out.println(bits2);
     // OR bits
     bits2.or(bits1);
     System.out.println("\nbits2 OR bits1: ");
     System.out.println(bits2);
     // XOR bits
     bits2.xor(bits1);
     System.out.println("\nbits2 XOR bits1: ");
     System.out.println(bits2);
  }
}
结果为：
Initial pattern in bits1:
{0, 2, 4, 6, 8, 10, 12, 14}
Initial pattern in bits2:
{1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 14}
bits2 AND bits1:
{2, 4, 6, 8, 12, 14}
bits2 OR bits1:
{0, 2, 4, 6, 8, 10, 12, 14}
bits2 XOR bits1:
{}

Java Vector类

Vector类实现了一个动态数组；和ArrayList很相似，但是两者时不同的：

• Vector是同步访问的
• Vector包含了许多传统的方法，这些方法不属于集合框架

Vector主要用在事先不知道数组的大小，或者只是需要一个可以改变大小的数组的情况
Vector类支持4中构造方法：

• 第一种构造方法创建了一个默认的向量，默认大小为10：

  Vector()

• 第二种构造方法创建指定大小的向量

  Vector(int size)

• 第三种构造方法创建指定大小的向量，并且增量用incr指定；增量表示向量每次增加的元素数目：

  Vector(int size,int incr)

• 第四种构造方法创建了一个包含集合c元素的向量：

  Vector(Collection c)

  除了从父类继承的方法外Vector还定义了以下方法：
  
  
  
  
  

  实例

  ```java import java.util.*;

public class VectorDemo {

public static void main(String args[]) { // initial size is 3, increment is 2 Vector v = new Vector(3, 2); System.out.println(“Initial size: “ + v.size()); System.out.println(“Initial capacity: “ + v.capacity()); v.addElement(new Integer(1)); v.addElement(new Integer(2)); v.addElement(new Integer(3)); v.addElement(new Integer(4)); System.out.println(“Capacity after four additions: “ + v.capacity());

  v.addElement(new Double(5.45));
  System.out.println("Current capacity: " +
  v.capacity());
  v.addElement(new Double(6.08));
  v.addElement(new Integer(7));
  System.out.println("Current capacity: " +
  v.capacity());
  v.addElement(new Float(9.4));
  v.addElement(new Integer(10));
  System.out.println("Current capacity: " +
  v.capacity());
  v.addElement(new Integer(11));
  v.addElement(new Integer(12));
  System.out.println("First element: " +
     (Integer)v.firstElement());
  System.out.println("Last element: " +
     (Integer)v.lastElement());
  if(v.contains(new Integer(3)))
     System.out.println("Vector contains 3.");
  // enumerate the elements in the vector.
  Enumeration vEnum = v.elements();
  System.out.println("\nElements in vector:");
  while(vEnum.hasMoreElements())
     System.out.print(vEnum.nextElement() + " ");
  System.out.println();

} }

结果为 Initial size: 0 Initial capacity: 3 Capacity after four additions: 5 Current capacity: 5 Current capacity: 7 Current capacity: 9 First element: 1 Last element: 12 Vector contains 3.

Elements in vector: 1 2 3 4 5.45 6.08 7 9.4 10 11 12

<a name="PqUaj"></a>
# Java Stack类
栈是Vector的一个子类，它实现了一个标准的后进先出的栈<br />堆栈只定义了默认构造函数，用来创建一个空栈；堆栈除了包括由Vector定义的所有方法，也定义了自己的一些方法
```java
Stack()

除了由Vector定义的所有方法，自己也定义了一些方法：

实例

import java.util.*;
public class StackDemo {
    static void showpush(Stack<Integer> st, int a) {
        st.push(new Integer(a));
        System.out.println("push(" + a + ")");
        System.out.println("stack: " + st);
    }
    static void showpop(Stack<Integer> st) {
        System.out.print("pop -> ");
        Integer a = (Integer) st.pop();
        System.out.println(a);
        System.out.println("stack: " + st);
    }
    public static void main(String args[]) {
        Stack<Integer> st = new Stack<Integer>();
        System.out.println("stack: " + st);
        showpush(st, 42);
        showpush(st, 66);
        showpush(st, 99);
        showpop(st);
        showpop(st);
        showpop(st);
        try {
            showpop(st);
        } catch (EmptyStackException e) {
            System.out.println("empty stack");
        }
    }
}
结果为
stack: [ ]
push(42)
stack: [42]
push(66)
stack: [42, 66]
push(99)
stack: [42, 66, 99]
pop -> 99
stack: [42, 66]
pop -> 66
stack: [42]
pop -> 42
stack: [ ]
pop -> empty stack

Java Dictionary类

Dictionary类是一个抽象类，用来存储 键/值对，作用和Map类相似
给出键和值，你就可以将值存储在Dictionary对象种；一旦该值被存储，就可以通过它的键来获取它；所有和Map一样，Dictionary也可以作为一个 键/值对列表

Dictionary类已经过时了；在实际开发中，你可以实现Map接口来获取键值对的存储功能

Java Hashtable类

Hashtable是原始的java.util的一部分，是一个Dictionary具体的实现
然而，Java2重构的Hashtable实现了Map接口，因此，Hashtable现在集成到了集合框架中；它和HashMap类很相似，但是它支持同步
像HashMap一样，Hashtable在哈希表中存储 键/值对；当使用一个哈希表，要指定用作键的对象，以及要链接到该键的值。
然后，该键经过哈希处理，所得到的散列码被用作存储在该表中值的索引
Hashtabel定义了四个构造方法：

• 第一个是默认构造方法

  Hashtable()

• 第二个构造函数创建指定大小的哈希表

  Hashtable(int size)

• 第三个构造方法创建了一个指定大小的哈希表，并且通过fillRatio指定填充比例（填充比例必须介于0.0和1.0之间，它决定了哈希表在重新调整大小之前的充满程度）

  Hashtale(int size,float fillRatio)

• 第四个构造方法创建了一个以M中元素为初始化元素的哈希表（哈希表的容量被设置为M的两倍）

  Hashtable(Map m)

  Hashtable中除了从Map接口中定义的方法外，还定义了以下方法：
  
  

  实例

  ```java import java.util.*;

public class HashTableDemo {

public static void main(String args[]) { // Create a hash map Hashtable balance = new Hashtable(); Enumeration names; String str; double bal;

  balance.put("Zara", new Double(3434.34));
  balance.put("Mahnaz", new Double(123.22));
  balance.put("Ayan", new Double(1378.00));
  balance.put("Daisy", new Double(99.22));
  balance.put("Qadir", new Double(-19.08));
  // Show all balances in hash table.
  names = balance.keys();
  while(names.hasMoreElements()) {
     str = (String) names.nextElement();
     System.out.println(str + ": " +
     balance.get(str));
  }
  System.out.println();
  // Deposit 1,000 into Zara's account
  bal = ((Double)balance.get("Zara")).doubleValue();
  balance.put("Zara", new Double(bal+1000));
  System.out.println("Zara's new balance: " +
  balance.get("Zara"));

} }

结果为 Qadir: -19.08 Zara: 3434.34 Mahnaz: 123.22 Daisy: 99.22 Ayan: 1378.0

Zara’s new balance: 4434.34

<a name="CnIhQ"></a>
# Java Properties类
Properties继承与Hashtable，表示一个持久的属性集，属性列表中每个键及其对应值都是一个字符串。<br />Properties类被许多Java类使用；例如，在获取环境变量时它就作为System.getProperties()方法的返回值<br />Properties定义如下实例变量，这个变量持有一个Properties对象相关的默认属性列表
```java
Properties defaults;

Properties类定义了两个构造方法，第一个构造方法没有默认值

Properties()

第二个构造方法使用propDefault作为默认值，两种情况下，属性列表都为空：

Properties(Properties propDefault)

除了从Hashtable中所定义的方法，Properties还定义了以下方法：

实例

import java.util.*;
public class PropDemo {
   public static void main(String args[]) {
      Properties capitals = new Properties();
      Set states;
      String str;
      capitals.put("Illinois", "Springfield");
      capitals.put("Missouri", "Jefferson City");
      capitals.put("Washington", "Olympia");
      capitals.put("California", "Sacramento");
      capitals.put("Indiana", "Indianapolis");
      // Show all states and capitals in hashtable.
      states = capitals.keySet(); // get set-view of keys
      Iterator itr = states.iterator();
      while(itr.hasNext()) {
         str = (String) itr.next();
         System.out.println("The capital of " +
            str + " is " + capitals.getProperty(str) + ".");
      }
      System.out.println();
      // look for state not in list -- specify default
      str = capitals.getProperty("Florida", "Not Found");
      System.out.println("The capital of Florida is "
          + str + ".");
   }
}
结果为:
The capital of Missouri is Jefferson City.
The capital of Illinois is Springfield.
The capital of Indiana is Indianapolis.
The capital of California is Sacramento.
The capital of Washington is Olympia.
The capital of Florida is Not Found.