一文带你深入了解Java的数据结构

目录

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

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

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

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

枚举接口（Enumeration）

枚举（Enumeration）接口虽然它本身不属于数据结构,但它在其他数据结构的范畴里应用很广。 枚举（The Enumeration）接口定义了一种从数据结构中取回连续元素的方式。例如，枚举定义了一个叫nextElement 的方法，该方法用来得到一个包含多元素的数据结构的下一个元素。

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

位集合（BitSet）

位集合类实现了一组可以单独设置和清除的位或标志。该类在处理一组布尔值的时候非常有用，你只需要给每个值赋值一"位"，然后对位进行适当的设置或清除，就可以对布尔值进行操作了。

一个Bitset类创建一种特殊类型的数组来保存位值。BitSet中数组大小会随需要增加。这和位向量（vector of bits）比较类似。这是一个传统的类，但它在Java 2中被完全重新设计。

BitSet定义了两个构造方法：

// 第一个构造方法创建一个默认的对象：
public BitSet()
// 第二个方法允许用户指定初始大小。所有位初始化为0
public BitSet(int nbits)

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

实例：

public class Test {
    public static void main(String args[]) throws IOException {
        BitSet bits1 = new BitSet(16);
        BitSet bits2 = new BitSet(16);
        // 设置一些位
        for(int i=0; i<16; i++) {
            if((i%2) == 0) bits1.set(i);
            if((i%5) != 0) bits2.set(i);
        }
        System.out.println("位集合1初始模式: ");
        System.out.println(bits1);
        System.out.println("\n位集合2初始模式: ");
        System.out.println(bits2);
        // 对此目标位 set 和参数位 set 执行逻辑与操作
        bits2.and(bits1);
        System.out.println("\n位集合2 与 位集合1 执行逻辑与操作 ");
        System.out.println(bits2);
        // 对此位 set 和位 set 参数执行逻辑或操作
        bits2.or(bits1);
        System.out.println("\n位集合2 与 位集合1 执行逻辑或操作: ");
        System.out.println(bits2);
        // 对此位 set 和位 set 参数执行逻辑异或操作
        bits2.xor(bits1);
        System.out.println("\n位集合2 与 位集合1 执行逻辑异或操作 ");
        System.out.println(bits2);
    }
}
// 程序编译运行结果如下：
// 位集合1初始模式: 
// {0, 2, 4, 6, 8, 10, 12, 14}
// 位集合2初始模式: 
// {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 14}
// 位集合2 与 位集合1 执行逻辑与操作 
// {2, 4, 6, 8, 12, 14}
// 位集合2 与 位集合1 执行逻辑或操作: 
// {0, 2, 4, 6, 8, 10, 12, 14}
// 位集合2 与 位集合1 执行逻辑异或操作 
// {}

向量（Vector）

向量（Vector）类和传统数组非常相似，但是Vector的大小能根据需要动态的变化。和数组一样，Vector对象的元素也能通过索引访问。使用Vector类最主要的好处就是在创建对象的时候不必给对象指定大小，它的大小会根据需要动态的变化。

Vector 与 ArrayList的区别：

• Vector 是同步访问的，所以线程就会安全，但是同时也会带来弊端就是效率就会降低，但 Arraylist 恰恰相反，这也就导致Arraylist的效率比 Vector 高。
• 在进行扩容时，Vector 会增长为原来数组长的一倍，而 Arraylist 只会增长为原来的一半，所以Arraylist节约内存空间。
• Vector 包含了许多传统的方法，这些方法不属于集合框架。

Vector 类支持 4 种构造方法：

// 第一种构造方法创建一个默认的向量，默认大小为 10
Vector()
// 第二种构造方法创建指定大小的向量
Vector(int size)
// 第三种构造方法创建指定大小的向量，并且增量用 incr 指定。增量表示向量每次增加的元素数目
Vector(int size,int incr)
// 第四种构造方法创建一个包含集合 c 元素的向量
Vector(Collection c)

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

实例：

public class Test {
    public static void main(String args[]) throws IOException {
        // 初始大小为3，增量为2
        Vector v = new Vector(3, 2);
        System.out.println("初始大小: " + v.size());
        System.out.println("初始容量: " + v.capacity());
        v.addElement(new Integer(1));
        v.addElement(new Double(5.45));
        v.addElement(new Double(6.08));
        v.addElement(new Integer(7));
        System.out.println("四次添加后的容量: " + v.capacity());
        v.addElement(new Float(9.4));
        System.out.println("当前容量: " + v.capacity());
        v.addElement(new Integer(10));
        System.out.println("当前容量: " + v.capacity());
        System.out.println("第一元素: " + (Integer)v.firstElement());
        System.out.println("最后一个元素: " + (Integer)v.lastElement());
        v.addElement(new Integer(3));
        // 向量包含3
        if(v.contains(new Integer(3))) {
            System.out.println("向量包含 3");
        }
        // 列举向量中的元素
        Enumeration vEnum = v.elements();
        System.out.println("\n向量中的元素:");
        while(vEnum.hasMoreElements()) {
            System.out.print(vEnum.nextElement() + " ");
        }
        System.out.println();
 www.devze.com   }
}
// 程序编译运行结果如下：
// 初始大小: 0
// 初始容量: 3
// 四次添加后的容量: 5
// 当前容量: 5
// 当前容量: 7
// 第一元素: 1
// 最后一个元素: 10
// 向量包含 3
// 向量中的元素:
// 1 5.45 6.08 7 9.4 10 3 

栈（Stack）

栈（Stack）实现了一个后进先出（LIFO）的数据结构。你可以把栈理解为对象的垂直分布的栈，当你添加一个新元素时，就将新元素放在其他元素的顶部。当你从栈中取元素的时候，就从栈顶取一个元素。换句话说，最后进栈的元素最先被取出。

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

字典（Dictionary）

字典（Dictionary） 类是一个抽象类，它定义了键映射到值的数据结构。当你想要通过特定的键而不是整数索引来访问数据的时候，这时候应该使用Dictionary。由于Dictionary类是抽象类，所以它只提供了键映射到值的数据结构，而没有提供特定的实现。

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

哈希表（Hashtable）

Hashtable类提供了一种在用户定义键结构的基础上来组织数据的手段。例如，在地址列表的哈希表中，你可以根据邮政编码作为键来存储和排序数据，而不是通过人名。哈希表键的具体含义完全取决于哈希表的使用情景和它包含的数据。

Hashtable是原始的java.util的一部分， 是一个Dictionary具体的实现 。然而，Java 2 重构的Hashtable实现了 Map 接口，因此，Hashtable 现在集成到了集合框架中。它和HashMap类很相似，但是它支持同步。

像HashMap一样，Hashtable在哈希表中存储键/值对。当使用一个哈希表，要指定用作键的对象，以及要链接到该键的值。然后，该键经过哈希处理，所得到的散列码被用作存储在该表中值的索引。

Hashtable定义了四个构造方法：

// 默认构造方法
public Hashtable()
// 创建编程客栈指定大小的哈希表
public Hashtable(int initialCapacity)
// 创建了一个指定大小的哈希表，并且通过fillRatio指定填充比例
// 填充比例必须介于0.0和1.0之间，它决定了哈希表在重新调整大小之前的充满程度
public Hashtable(int initialCapacity, float loadFactor)
// 创建了一个以 t 中元素为初始化元素的哈希表，哈希表的容量被设置为 t 的两倍
public Hashtable(Map<? extends K, ? extends V> t) 

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

属性（Properties）

Properties 继承于 Hashtable。Properties 类表示了一个持久的属性集。属性列表中每个键及其对应值都是一个字符串。Properties 类被许多Java类使用。例如，在获取环境变量时它就作为System.getProperties()方法的返回值。

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

protected Properties defaults;

Properties类定义了两个构造方法：

// 第一个构造方法没有默认值
public Properties()
// 第二个构造方法使用propDefault 作为默认值
public Properties(Properties defaults)

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

以上就是一文带你深入了解Java的数据结构的详细内容，更多关于Java数据结构的资料请关注我们其它相关文章！