Java工具包中包含许多强大的数据结构，主要包括
枚举（Enumeration）；
位集合（BitSet）；
向量（Vector）；
栈（Stack）；
字典（Dictionary）；
哈希表（Hashtable）；
属性（Properties）；
下面是详细的叙述和实例：
1、枚举（Enumeration）；
枚举的定义是从其它数据结构中取出连续元素，而它本身并不是一种数据结构，现在已经基本上被迭代器所取代，但在某些方面仍有使用，如应用在Vector和Properties等少数传统类中，另外还有一些API类，以及应用程序中，下面以枚举在Vector中的应用为例：
import java.util.Enumeration;
import java.util.Vector;
//从Vector中取出连续元素
public class EnumerationTest {
public EnumerationTest(){
Enumeration days; //申明枚举对象days
Vector daysNames =new Vector<>(); //申明一个Vector，存放元素
daysNames.add("Java"); //向Vector中存放元素
daysNames.add("数");
daysNames.add("据");
daysNames.add("结");
daysNames.add("构");
days = daysNames.elements();
while (days.hasMoreElements()){ //hasMoreElements()方法用于测试此枚举是否包含更多元素
System.out.println(days.nextElement()); //nextElement()方法测试此枚举是否存在下一个元素，若存在返回此枚举的下一个元素，否则结束
}
}
}
测试成功输出控制台显示如下信息：
2、位集合（BitSet）；
位集合类实现了一组可以单独设置和清除的位或标志。 该类在处理一组布尔值时比较高效，只需要给每个值赋值一"位"，然后对位进行适当的设置或清除，就可以对布尔值进行操作了。位集合实际上类似于数学中的集合，然后对集合进行操作，相关操作有： void set(int index) 设置index所在的布尔值为true； void clear(int index)设置index所在的布尔值为false； void and(BitSet set)执行逻辑与操作 void or(BitSet bitSet)执行逻辑或操作。 void xor(BitSet bitSet)执行逻辑异或操作。 下面是Java代码实例
import java.util.BitSet;
//Java数据结构-位运算
public class BitSetTest {
public BitSetTest(){
BitSet bit1 =new BitSet(10);
BitSet bit2 =new BitSet(10);
for(int i=0;i<10;i++){
if(i%2==0) bit1.set(i);
if(i%3==0) bit2.set(i);
}
System.out.println("bit1中的元素有"+bit1);
System.out.println("bit2中的元素有"+bit2);
bit1.and(bit2); //逻辑与运算
System.out.println("bit1和bit2进行与运算的结果为"+bit1);
System.out.println("--------------------------------------------------");
System.out.println("bit1中的元素有"+bit1);
System.out.println("bit2中的元素有"+bit2);
bit1.or(bit2); //逻辑或运算
System.out.println("bit1和bit2进行或运算的结果为"+bit2);
System.out.println("--------------------------------------------------");
System.out.println("bit1中的元素有"+bit1);
System.out.println("bit2中的元素有"+bit2);
bit1.xor(bit2); //逻辑异或运算
System.out.println("bit1和bit2进行异或运算的结果为"+bit1);
}
}
测试成功输出控制台显示如下信息：
3、向量（Vector）；
Vector 类实现了一个动态数组。和 ArrayList 很相似，但是两者不同，Vector 包含了许多不属于集合框架的传统方法，Vector 主要用于不确定数组的大小，或者说是一个可以改变大小的数组的情况。相关操作有
void addElement(Object obj) 将指定的组件添加到此向量的末尾，将其大小增加 1。 int capacity() 返回此向量的当前容量。 int size() 返回此向量中的组件数。 Object firstElement() 返回此向量的第一个组件（位于索引 0)处的项）。 Object lastElement() 返回此向量的最后一个组件。 boolean contains(Collection c) 如果此向量包含指定 Collection 中的所有元素，则返回 true。 下面是Java代码实例
import java.util.Enumeration;
import java.util.Vector;
//Java数据结构-向量（Vector）
public class VectorTest {
public VectorTest(){
Vector v =new Vector(2,2); //申明Vector对象，设置初始容量为2，增量为2
Enumeration num;//申明枚举对象num
System.out.println("向量中组件数量为:"+v.size()); //返回向量中组件数量
System.out.println("向量初始容量为:"+v.capacity()); //返回向量容量
System.out.println("-------------------------------------------");
v.addElement(new Integer(1)); //往向量中增加组件
v.addElement(new Integer(2));
v.addElement(new Double(1.52)); //添加组件超过初始容量，自动增加2
//v.addElement(new String("java"));
System.out.println("增加向量组件后向量的组件数量为:"+v.size()); //返回增加组件后的向量的组件数量
System.out.println("增加向量组件后向量的容量为:"+v.capacity()); //返回增加组件后的向量的容量大小
System.out.println("-------------------------------------------");
System.out.println("向量中的第一个组件为："+v.firstElement()); //返回向量的第一个组件
System.out.println("向量中的最后一个组件为："+v.lastElement()); //返回向量的最后一个组件
System.out.println("-------------------------------------------");
if(v.contains(new Integer(1))) //测试向量中是否含有组件1
System.out.println("向量中包含组件1");
num = v.elements(); //通过枚举对象取出向量中的组件
while(num.hasMoreElements())
System.out.print(num.nextElement()+" ");
}
}
测试成功输出控制台显示如下信息：
4、栈（Stack）；
栈（Stack）实现了一个后进先出（LIFO）的数据结构。可以理解为垂直存储，先进的放置在底部，后进的放置在上面，取出是自顶向下取出。相关操作有：
Object push(Object element)把项压入堆栈顶部。 Object pop( )移除堆栈顶部的对象，并作为此函数的值返回该对象。
下面是Java代码实例
import java.util.Stack;
//Java数据结构-栈（Stack）
public class StackTest {
public StackTest(){
Stack st =new Stack<>(); //申明栈对象st
for(int i=0;i<3;i++){
st.push(new Integer(i)); //元素入栈
System.out.println("(" + i +")入栈");
}
System.out.println("当前栈的元素有： " + st);
System.out.println("取出栈顶元素："+st.pop() ); //取出栈顶元素
System.out.println("当前栈的元素有： " + st); //查看取出栈顶元素后的栈元素
}
}
测试成功输出控制台显示如下信息：
5、字典（Dictionary）；
字典（Dictionary） 类是一个抽象类，它定义了键映射到值的数据结构。字典是通过特定的键而不是整数索引来访问数据。在现代Dictionary类已经过时，在实际开发中，通过实现Map接口来获取键/值的存储功能。
6、哈希表（Hashtable）；
Hashtable类提供了一种在用户定义键结构的基础上来组织数据的手段。哈希表键的具体含义完全取决于哈希表的使用情景和它包含的数据。一个哈希表，要指定用作键的对象，以及要链接到该键的值，该键经过哈希处理，所得到的散列码被用作存储在该表中值的索引。相关操作有：
Object put(Object key, Object value)将指定 key 映射到此哈希表中的指定 value。 Enumeration keys( )返回此哈希表中的键的枚举。 Object get(Object key)返回指定键所映射到的值，如果此映射不包含此键的映射，则返回 null. 更确切 地讲，如果此映射包含满足 (key.equals(k)) 的从键 k 到值 v 的映射，则此方法返回 v；否则，返回 null。
下面是Java代码实例
import java.util.Enumeration;
import java.util.Hashtable;
//Java数据结构-哈希表（HashTable）
public class HashTableTest {
public HashTableTest() {
Hashtable hash =new Hashtable(); //申明HashTable对象hashEnumeration num;//申明枚举对象num
String str;
Double doub;
hash.put("book",new Double(1.11)); //在哈希表中添加键值对
hash.put("paper",new Double(2.22));
num = hash.keys(); //通过枚举取出哈希表中的键
while(num.hasMoreElements()){
str = (String)num.nextElement();
System.out.println("商品名称："+str+" 价格："+hash.get(str));
}
doub = ((Double)hash.get("book")).doubleValue();
hash.put("book",new Double(doub+100)); //修改哈希表中相关键的值
System.out.println("book的新价格为："+hash.get("book"));
}
}
测试成功输出控制台显示如下信息：
7、属性（Properties）；
Properties 继承于 Hashtable.Properties 类表示了一个持久的属性集，所以具有HashTable的相关方法，属性列表中每个键及其对应值都是一个字符串。可用于获取环境变量时它就作为System.getProperties()方法的返回值。相关操作有：
String getProperty(String key)用指定的键 在此属性列表中搜索属性。 String getProperty(String key, String defaultProperty)用指定的键在属性列表中搜索属性。
下面是Java代码实例
import java.util.Iterator;
import java.util.Properties;
import java.util.Set;
public class PropertiesTest {
public PropertiesTest(){
Properties pro =new Properties(); //申明Properties对象 pro
Set state;
String str;
pro.put("admin","111"); //设置键值对
pro.put("normal","222");
state = pro.keySet(); //将键值对添加到HashTable
Iterator itr = state.iterator(); //申明迭代器对象itr，取出键值对
while (itr.hasNext()){ //判断是否存在下一组键值对
str = (String) itr.next(); //返回下一组键值对
System.out.println("账号为："+
str +" 密码为：" + pro.getProperty(str) +".");
}
str = pro.getProperty("leader","不存在"); //不存在的键，其值设置为“不存在”
System.out.println("账户为leader" + str);
}
}
测试成功输出控制台显示如下信息：
