Java 数据结构

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 + ".");
       }
}