Java中的数据结构有哪些?（java常见的数据结构和算法）

数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。

Q：java中的数据结构有哪些呢？

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

注意：集合框架(Collection)，后续单独总结。

接下来我们一一介绍

• 枚举（Enumeration）

枚举它本不属于数据结构范畴，但是它在其它的数据结构范畴里应用很广。 它定义了一种从数据结构中取回连续元素的方式。

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

import java.util.Vector;
import java.util.Enumeration;
 
public class EnumerationTest {
 
 public static void main(String args[]) {
 Enumeration<String> days;
 Vector<String> dayNames = new Vector<String>();
 //注意 定义的数据类型有对应
 dayNames.add("周一");
 dayNames.add("周二");
 dayNames.add("周三");
 dayNames.add("周四");
 dayNames.add("周五");
 dayNames.add("周六");
 dayNames.add("周天");
 days = dayNames.elements();
 while (days.hasMoreElements()){
 System.out.println(days.nextElement()); 
 }
 }
}

• 位集合（BitSet）

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

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

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 bits 将指定索引处的位设置为 true
 for(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 对此目标位 set 和参数位 set 执行逻辑与操作。
 bits2.and(bits1);
 System.out.println("\nbits2 AND bits1: ");
 System.out.println(bits2);
 
 // OR bits 对此位 set 和位 set 参数执行逻辑或操作。
 bits2.or(bits1);
 System.out.println("\nbits2 OR bits1: ");
 System.out.println(bits2);
 
 // XOR bits 对此位 set 和位 set 参数执行逻辑异或操作。
 bits2.xor(bits1);
 System.out.println("\nbits2 XOR bits1: ");
 System.out.println(bits2);
 }
}

• 向量（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)

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

也定义了自己的一些方法。

import java.util.*;
 
public class StackDemo {
 
 static void showpush(Stack<Integer> st, int a) {
 st.push(new Integer(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("stack: " + st);
 }
 
 public static void main(String args[]) {
 Stack<Integer> st = new Stack<Integer>();
 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类相似。现在已过时，使用map替代。

• 哈希表（Hashtable）

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

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

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

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)

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

• 属性（Properties）

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

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

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

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

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

Properties defaults;

Properties类定义了两个构造方法. 第一个构造方法没有默认值。

Properties()

第二个构造方法使用propDefault 作为默认值。两种情况下，属性列表都为空：

Properties(Properties propDefault)

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 keys
 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();
 
 // look for state not in list -- specify default
 str = 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.