Java工具包提供了强大的数据结构。在Java中的数据结构主要包括以下几种接口和类：
枚举（Enumeration）
位集合（BitSet）
向量（Vector）
栈（Stack）
字典（Dictionary）
哈希表（Hashtable）
属性（Properties）
以上这些类是传统遗留的，在Java2中引入了一种新的框架-集合框架(Collection)。
1.枚举（Enumeration）
枚举（Enumeration）接口虽然它本身不属于数据结构,但它在其他数据结构的范畴里应用很广。枚举接口定义了一种从数据结构中取回连续元素的方式。
例如，枚举定义了一个叫nextElement的方法，该方法用来得到一个包含多元素的数据结构的下一个元素。
这种传统接口已被迭代器取代，虽然Enumeration还未被遗弃，但在现代代码中已经被很少使用了。尽管如此，它还是使用在诸如Vector和Properties这些传统类所定义的方法中，除此之外，还用在一些API类，并且在应用程序中也广泛被使用。
boolean hasMoreElements( )
//测试此枚举是否包含更多的元素。
Object nextElement( )
//如果此枚举对象至少还有一个可提供的元素，则返回此枚举的下一个元素。
import java.util.Enumeration;
import java.util.Vector;
public class JavaEnumeration {
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());
}
}
}
2.位集合（BitSet）
位集合类实现了一组可以单独设置和清除的位或标志。该类在处理一组布尔值的时候非常有用，只需要给每个值赋值一"位"，然后对位进行适当的设置或清除，就可以对布尔值进行操作了。
import java.util.BitSet;
public class JavaBitSet {
public static void main(String[] args) {
BitSet bit1 = new BitSet(16);
BitSet bit2 = new BitSet(16);
//给BitSet设置值
for (int i = 0; i < 16; i++) {
if ((i%2) == 0) {
bit1.set(i);
}
if ((i%5) != 0) {
bit2.set(i);
}
}
System.out.println(bit1); //{0, 2, 4, 6, 8, 10, 12, 14}
System.out.println(bit2); //{1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 14}
//and (对此目标位 set 和参数位 set 执行逻辑与操作)
bit2.and(bit1);
System.out.println(bit2); //{2, 4, 6, 8, 12, 14}
//or （对此目标位 set 和参数位 set 执行逻辑或操作）
bit2.or(bit1);
System.out.println(bit2); //{0, 2, 4, 6, 8, 10, 12, 14}
//xor （对此目标位 set 和参数位 set 执行逻辑异或操作）
bit2.xor(bit1);
System.out.println(bit2); //{}
}
}
3.向量（Vector）
向量（Vector）类和传统数组非常相似，但是Vector的大小能根据需要动态的变化。和数组一样，Vector对象的元素也能通过索引访问。使用Vector类最主要的好处就是在创建对象的时候不必给对象指定大小，它的大小会根据需要动态的变化。
Vector 主要用在事先不知道数组的大小，或者只是需要一个可以改变大小的数组的情况。
Vector 类实现了一个动态数组。和ArrayList很相似，但是两者是不同的：
1.Vector 是同步访问的
2.Vector 包含了许多传统的方法，这些方法不属于集合框架
Vector 类支持 4 种构造方法：
Vector() //创建一个默认的向量，默认大小为 10
Vector(int size) //创建指定大小的向量
Vector(int size,int incr) //创建指定大小的向量，并且增量用incr指定。增量表示向量每次增加的元素数目
Vector(Collection c) //创建一个包含集合 c 元素的向量
import java.util.Enumeration;
import java.util.Vector;
public class JavaVector {
public static void main(String[] args) {
Vector<Number> v = new Vector<Number>(3, 2);
//size()返回此向量中的组件数
System.out.println(v.size()); //0
//capacity()返回此向量的当前容量
System.out.println(v.capacity()); //3
v.addElement(1);
v.addElement(2);
v.addElement(3);
v.addElement(4);
System.out.println(v.capacity()); //5
v.addElement(5.0);
System.out.println(v.capacity()); //5
v.addElement(6.0);
v.addElement(7.0);
System.out.println(v.capacity()); //7
System.out.println(v.firstElement()); //1
System.out.println(v.lastElement()); //7.0
System.out.println(v.contains(5)); //false
Enumeration e = v.elements();
while (e.hasMoreElements()) {
System.out.print(e.nextElement() + " ");
} //1 2 3 4 5.0 6.0 7.0
}
}
4.栈（Stack）
栈是Vector的一个子类，它实现了一个后进先出（LIFO）的数据结构。可以把栈理解为对象的垂直分布的栈，当添加一个新元素时，就将新元素放在其他元素的顶部。当从栈中取元素的时候，就从栈顶取一个元素。换句话说，最后进栈的元素最先被取出的。
堆栈只定义了默认构造函数，用来创建一个空栈。堆栈除了包括由Vector定义的所有方法，也定义了自己的一些方法。
import java.util.EmptyStackException;
import java.util.Stack;
public class JavaStack {
static void showpush(Stack<Integer> st, int a) {
st.push(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(st);
}
public static void main(String[] args) {
Stack<Integer> st = new Stack<Integer>();
System.out.println("stack:" + st);
showpush(st, 10);
showpush(st, 20);
showpush(st, 30);
showpop(st);
showpop(st);
showpop(st);
try {
showpop(st);
} catch (EmptyStackException e) {
System.out.println("empty stack");
}
}
}
5.字典（Dictionary）
字典（Dictionary）类是一个抽象类，用来存储键/值对，作用和Map类相似。它定义了键映射到值的数据结构。当要通过特定的键而不是整数索引来访问数据的时候，这时候应该使用Dictionary。由于Dictionary类是抽象类，所以它只提供了键映射到值的数据结构，而没有提供特定的实现。
Dictionary类已经过时了。在实际开发中，可以实现Map接口来获取键/值的存储功能。
6.Map接口
Map接口中键和值一一映射. 可以通过键来获取值。
1.给定一个键和一个值，可以将该值存储在一个Map对象.之后，可以通过键来访问对应的值。
2.当访问的值不存在的时候，方法就会抛出一个NoSuchElementException异常。
3.当对象的类型和Map里元素类型不兼容的时候，就会抛出一个 ClassCastException异常。
4.当在不允许使用Null对象的Map中使用Null对象，会抛出一个NullPointerException 异常。
5.当尝试修改一个只读的Map时，会抛出一个UnsupportedOperationException异常。
void clear( )
//从此映射中移除所有映射关系（可选操作）。
boolean containsKey(Object k)
//如果此映射包含指定键的映射关系，则返回 true。
boolean containsValue(Object v)
//如果此映射将一个或多个键映射到指定值，则返回 true。
Set entrySet( )
//返回此映射中包含的映射关系的 Set 视图。
boolean equals(Object obj)
//比较指定的对象与此映射是否相等。
Object get(Object k)
//返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
int hashCode( )
//返回此映射的哈希码值。
boolean isEmpty( )
//如果此映射未包含键-值映射关系，则返回 true。
Set keySet( )
//返回此映射中包含的键的 Set 视图。
Object put(Object k, Object v)
//将指定的值与此映射中的指定键关联（可选操作）。
void putAll(Map m)
//从指定映射中将所有映射关系复制到此映射中（可选操作）。
Object remove(Object k)
//如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
int size( )
//返回此映射中的键-值映射关系数。
Collection values( )
//返回此映射中包含的值的 Collection 视图。
import java.util.*;
public class JavaMap {
public static void main(String[] args) {
Map m1 = new HashMap();
m1.put("xiaoli", "15");
m1.put("xiaowang", "20");
m1.put("xiaoliu", "25");
m1.put("xiaocai", "30");
System.out.println(m1); //{xiaoli=15, xiaowang=20, xiaoliu=25, xiaocai=30}
System.out.println(m1.values()); //[15, 20, 25, 30]
}
}
7.哈希表（Hashtable）
Hashtable类提供了一种在用户定义键结构的基础上来组织数据的手段。例如，在地址列表的哈希表中，可以根据邮政编码作为键来存储和排序数据，而不是通过人名。哈希表键的具体含义完全取决于哈希表的使用情景和它包含的数据。
Hashtable是原始的java.util的一部分，是一个Dictionary具体的实现。然而，Java2重构的Hashtable实现了Map接口，因此，Hashtable现在集成到了集合框架中。它和HashMap类很相似，但是它支持同步。
Hashtable定义了四个构造方法：
Hashtable() //默认构造方法
Hashtable(int size) //指定大小的哈希表
Hashtable(int size,float fillRatio)
//创建了一个指定大小的哈希表，并且通过fillRatio指定填充比例
//填充比例必须介于0.0和1.0之间，它决定了哈希表在重新调整大小之前的充满程度
Hashtable(Map m) //创建了一个以M中元素为初始化元素的哈希表。哈希表的容量被设置为M的两倍
import java.util.*;
public class JavaHashtable {
public static void main(String[] args) {
Hashtable<String, Double> balance = new Hashtable<String, Double>();
Enumeration names;
String str;
double bal;
balance.put("Zara", 123.11);
balance.put("Mahnaz", 234.0);
balance.put("Ayan", 120.);
balance.put("Daisy", -10.0);
balance.put("Qadir", -33.3);
names = balance.keys();
while (names.hasMoreElements()) {
str = (String) names.nextElement();
System.out.println(str + ": " + balance.get(str));
}
bal = ((Double)balance.get("Zara")).doubleValue();
balance.put("Zara", 1000.0);
System.out.println("Zara's new balance: " + balance.get("Zara"));
}
}
8.属性（Properties）
Properties 继承于Hashtable.Properties类表示了一个持久的属性集.属性列表中每个键及其对应值都是一个字符串。Properties 类被许多Java类使用。例如，在获取环境变量时它就作为System.getProperties()方法的返回值。
import java.util.*;
public class JavaProperties {
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");
states = capitals.keySet();
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();
str = capitals.getProperty("Florida", "Not Found");
System.out.println("The capital of Florida is "
+ str + ".");
}
}
