（二十六）Java 数据结构

目录

一. 前言

二. 枚举（Enumeration）

三. 位集合（BitSet）

四. 向量（Vector）

五. 栈（Stack）

六. 字典（Dictionary）

七. 哈希表（Hashtable）

八. 属性（Properties）

一. 前言

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

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

以上这些类是传统遗留的，在Java2中引入了一种新的框架-集合框架(Collection)，我们后面再讨论。

二. 枚举（Enumeration）

枚举（Enumeration）接口虽然它本身不属于数据结构,但它在其他数据结构的范畴里应用很广。 枚举（The Enumeration）接口定义了一种从数据结构中取回连续元素的方式。

例如，枚举定义了一个叫 nextElement 的方法，该方法用来得到一个包含多元素的数据结构的下一个元素。

Enumeration 接口中定义了一些方法，通过这些方法可以枚举（一次获得一个）对象集合中的元素。

这种传统接口已被迭代器取代，虽然 Enumeration 还未被遗弃，但在现代代码中已经被很少使用了。尽管如此，它还是使用在诸如 Vector 和 Properties 这些传统类所定义的方法中，除此之外，还用在一些 API 类，并且在应用程序中也广泛被使用。 下表总结了一些 Enumeration 声明的方法：

以下实例演示了 Enumeration 的使用：

import java.util.Vector;
import java.util.Enumeration;public class EnumerationTester {public static void main(String args[]) {Enumeration days;Vector dayNames = new Vector();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）

位集合类实现了一组可以单独设置和清除的位或标志。

该类在处理一组布尔值的时候非常有用，你只需要给每个值赋值一“位”，然后对位进行适当的设置或清除，就可以对布尔值进行操作了。

一个 Bitset 类创建一种特殊类型的数组来保存位值。BitSet 中数组大小会随需要增加。这和位向量（vector of bits）比较类似。

这是一个传统的类，但它在Java 2中被完全重新设计。

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 bitsfor(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:
{}

四. 向量（Vector）

向量（Vector）类和传统数组非常相似，但是 Vector 的大小能根据需要动态的变化。

和数组一样，Vector 对象的元素也能通过索引访问。

使用 Vector 类最主要的好处就是在创建对象的时候不必给对象指定大小，它的大小会根据需要动态的变化。

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

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

Vector 主要用在事先不知道数组的大小，或者只是需要一个可以改变大小的数组的情况。

Vector 类支持4种构造方法。

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

Vector()

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

Vector(int size)

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

Vector(int size, int incr)

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

Vector(Collection c)

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

下面的程序说明这个集合所支持的几种方法：

import java.util.*;public class VectorDemo {public static void main(String[] args) {// initial size is 3, increment is 2Vector 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

五. 栈（Stack）

栈（Stack）实现了一个后进先出（LIFO）的数据结构。

你可以把栈理解为对象的垂直分布的栈，当你添加一个新元素时，就将新元素放在其他元素的顶部。

当你从栈中取元素的时候，就从栈顶取一个元素。换句话说，最后进栈的元素最先被取出。

栈是 Vector 的一个子类，它实现了一个标准的后进先出的栈。

堆栈只定义了默认构造函数，用来创建一个空栈。 堆栈除了包括由 Vector 定义的所有方法，也定义了自己的一些方法。

Stack()

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

下面的程序说明这个集合所支持的几种方法：

import java.util.*;public class StackDemo {static void showpush(Stack st, int a) {st.push(new Integer(a));System.out.println("push(" + a + ")");System.out.println("stack: " + st);}static void showpop(Stack 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 st = new Stack();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

六. 字典（Dictionary）

字典（Dictionary） 类是一个抽象类，它定义了键映射到值的数据结构。

当你想要通过特定的键而不是整数索引来访问数据的时候，这时候应该使用 Dictionary。

由于 Dictionary 类是抽象类，所以它只提供了键映射到值的数据结构，而没有提供特定的实现。

Dictionary 类是一个抽象类，用来存储键/值对，作用和 Map 类相似。

给出键和值，你就可以将值存储在 Dictionary 对象中。一旦该值被存储，就可以通过它的键来获取它。所以和 Map 一样， Dictionary 也可以作为一个键/值对列表。

Dictionary 定义的抽象方法如下表所示：

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

七. 哈希表（Hashtable）

Hashtable 类提供了一种在用户定义键结构的基础上来组织数据的手段。

例如，在地址列表的哈希表中，你可以根据邮政编码作为键来存储和排序数据，而不是通过人的名字。

哈希表键的具体含义完全取决于哈希表的使用情景和它包含的数据。

Hashtable 是原始的 java.util 的一部分， 是一个 Dictionary 具体的实现 。

然而，Java 2 重构的 Hashtable 实现了 Map 接口，因此，Hashtable 现在集成到了集合框架中。它和 HashMap 类很相似，但是它支持同步。

像 HashMap 一样，Hashtable 在哈希表中存储键/值对。当使用一个哈希表，要指定用作键的对象，以及要链接到该键的值。

然后，该键经过哈希处理，所得到的散列码被用作存储在该表中值的索引。

Hashtable 定义了四个构造方法。第一个是默认构造方法：

Hashtable()

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

Hashtable(int size)

第三个构造方法创建了一个指定大小的哈希表，并且通过 fillRatio 指定填充比例。

填充比例必须介于0.0和1.0之间，它决定了哈希表在重新调整大小之前的充满程度：

Hashtable(int size,float fillRatio)

第四个构造方法创建了一个以 M 中元素为初始化元素的哈希表。

哈希表的容量被设置为 M 的两倍。

Hashtable(Map m)

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

下面的程序说明这个数据结构支持的几个方法：

import java.util.*;public class HashTableDemo {public static void main(String[] args) {// Create a hash mapHashtable 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 accountbal = ((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.0Zara's new balance: 4434.34

八. 属性（Properties）

Properties 继承于 Hashtable.Properties 类表示了一个持久的属性集.属性列表中每个键及其对应值都是一个字符串。

Properties 类被许多 Java 类使用。例如，在获取环境变量时它就作为 System.getProperties() 方法的返回值。

Properties 定义如下实例变量，这个变量持有一个 Properties 对象相关的默认属性列表。

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 keysIterator 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 defaultstr = 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.