Java 資料結構

Java工具包提供了強大的資料結構。在Java中的資料結構主要包括以下幾種接口和類：

枚舉（Enumeration）：枚舉（一次獲得一個）對象集合中的元素。（java.util.Enumeration）
位集合（BitSet）：給每個值指派一"位"，對布爾值進行操作。（java.util.BitSet）
向量（Vector）：大小能根據需要動态的變化。（java.util.Vector）
棧（Stack）：後進先出。（棧是Vector的一個子類，java.util.*）
字典（Dictionary）：元素是鍵值對，已被 Map 取代。（元素無序）（java.util.*）
哈希表（Hashtable）：是一個Dictionary具體的實作，并對鍵進行哈希處理。（java.util.*）
屬性（Properties）：Properties 繼承于 Hashtable.Properties 類，屬性清單中每個鍵及其對應值都是一個字元串。（java.util.*）

枚舉（Enumeration）

枚舉（Enumeration）接口雖然它本身不屬于資料結構,但它在其他資料結構的範疇裡應用很廣。枚舉（The Enumeration）接口定義了一種從資料結構中取回連續元素的方式。

Enumeration接口中定義了一些方法，通過這些方法可以枚舉（一次獲得一個）對象集合中的元素。

這種傳統接口已被疊代器取代，雖然Enumeration 還未被遺棄，但在現代代碼中已經被很少使用了。盡管如此，它還是使用在諸如Vector和Properties這些傳統類所定義的方法中，除此之外，還用在一些API類，并且在應用程式中也廣泛被使用。下表總結了一些Enumeration聲明的方法：

序号	方法描述
1	boolean hasMoreElements( ) 測試此枚舉是否包含更多的元素。
2	Object nextElement( ) 如果此枚舉對象至少還有一個可提供的元素，則傳回此枚舉的下一個元素。

序号

方法描述

boolean hasMoreElements( )

測試此枚舉是否包含更多的元素。

Object nextElement( )

如果此枚舉對象至少還有一個可提供的元素，則傳回此枚舉的下一個元素。

執行個體

以下執行個體示範了Enumeration的使用：

import java.util.Vector;
import java.util.Enumeration;
 
public class EnumerationTester {
 
   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()); 
      }
   }
}

位集合（BitSet）

位集合類實作了一組可以單獨設定和清除的位或标志。

該類在處理一組布爾值的時候非常有用，你隻需要給每個值指派一"位"，然後對位進行适當的設定或清除，就可以對布爾值進行操作了。

一個Bitset類建立一種特殊類型的數組來儲存位值。BitSet中數組大小會随需要增加。這和位向量（vector of bits）比較類似。

這是一個傳統的類，但它在Java 2中被完全重新設計。

BitSet定義了兩個構造方法。

第一個構造方法建立一個預設的對象：

BitSet()

第二個方法允許使用者指定初始大小。所有位初始化為0。

BitSet(int size)

BitSet中實作了Cloneable接口中定義的方法如下表所列：

序号	方法描述
1	void and(BitSet set) 對此目标位 set 和參數位 set 執行邏輯與操作。
2	void andNot(BitSet set) 清除此 BitSet 中所有的位，其相應的位在指定的 BitSet 中已設定。
3	int cardinality( ) 傳回此 BitSet 中設定為 true 的位數。
4	void clear( ) 将此 BitSet 中的所有位設定為 false。
5	void clear(int index) 将索引指定處的位設定為 false。
6	void clear(int startIndex, int endIndex) 将指定的 startIndex（包括）到指定的 toIndex（不包括）範圍内的位設定為 false。
7	Object clone( ) 複制此 BitSet，生成一個與之相等的新 BitSet。
8	boolean equals(Object bitSet) 将此對象與指定的對象進行比較。
9	void flip(int index) 将指定索引處的位設定為其目前值的補碼。
10	void flip(int startIndex, int endIndex) 将指定的 fromIndex（包括）到指定的 toIndex（不包括）範圍内的每個位設定為其目前值的補碼。
11	boolean get(int index) 傳回指定索引處的位值。
12	BitSet get(int startIndex, int endIndex) 傳回一個新的 BitSet，它由此 BitSet 中從 fromIndex（包括）到 toIndex（不包括）範圍内的位組成。
13	int hashCode( ) 傳回此位 set 的哈希碼值。
14	boolean intersects(BitSet bitSet) 如果指定的 BitSet 中有設定為 true 的位，并且在此 BitSet 中也将其設定為 true，則傳回 true。
15	boolean isEmpty( ) 如果此 BitSet 中沒有包含任何設定為 true 的位，則傳回 true。
16	int length( ) 傳回此 BitSet 的"邏輯大小"：BitSet 中最高設定位的索引加 1。
17	int nextClearBit(int startIndex) 傳回第一個設定為 false 的位的索引，這發生在指定的起始索引或之後的索引上。
18	int nextSetBit(int startIndex) 傳回第一個設定為 true 的位的索引，這發生在指定的起始索引或之後的索引上。
19	void or(BitSet bitSet) 對此位 set 和位 set 參數執行邏輯或操作。
20	void set(int index) 将指定索引處的位設定為 true。
21	void set(int index, boolean v) 将指定索引處的位設定為指定的值。
22	void set(int startIndex, int endIndex) 将指定的 fromIndex（包括）到指定的 toIndex（不包括）範圍内的位設定為 true。
23	void set(int startIndex, int endIndex, boolean v) 将指定的 fromIndex（包括）到指定的 toIndex（不包括）範圍内的位設定為指定的值。
24	int size( ) 傳回此 BitSet 表示位值時實際使用空間的位數。
25	String toString( ) 傳回此位 set 的字元串表示形式。
26	void xor(BitSet bitSet) 對此位 set 和位 set 參數執行邏輯異或操作。

執行個體

下面的程式說明這個資料結構支援的幾個方法：

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
     for(int i=0; i<16; i++) {
        if((i%2) == 0) bits1.set(i);     // 将指定索引處的位設定為 true
        if((i%5) != 0) bits2.set(i);     // 将指定索引處的位設定為 true
     }
     System.out.println("Initial pattern in bits1: ");
     System.out.println(bits1);
     System.out.println("\nInitial pattern in bits2: ");
     System.out.println(bits2);
 
     // AND bits
     bits2.and(bits1);                   // 對此目标位 set 和參數位 set 執行邏輯與操作
     System.out.println("\nbits2 AND bits1: ");
     System.out.println(bits2);      
 
     // OR bits
     bits2.or(bits1);                     // 對此位 set 和位 set 參數執行邏輯或操作
     System.out.println("\nbits2 OR bits1: ");
     System.out.println(bits2);
 
     // XOR bits
     bits2.xor(bits1);                    // 對此位 set 和位 set 參數執行邏輯異或操作
     System.out.println("\nbits2 XOR bits1: ");
     System.out.println(bits2);
  }
}

/*
Initial pattern in bits1:
{0, 2, 4, 6, 8, 10, 12, 14}

Initial pattern in bits2:
{1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 14}

bits2 AND bits1:
{2, 4, 6, 8, 12, 14}

bits2 OR bits1:
{0, 2, 4, 6, 8, 10, 12, 14}

bits2 XOR bits1:
{}
*/

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

除了從父類繼承的方法外 Vector 還定義了以下方法：

序号	方法描述
1	void add(int index, Object element) 在此向量的指定位置插入指定的元素。
2	boolean add(Object o) 将指定元素添加到此向量的末尾。
3	boolean addAll(Collection c) 将指定 Collection 中的所有元素添加到此向量的末尾，按照指定 collection 的疊代器所傳回的順序添加這些元素。
4	boolean addAll(int index, Collection c) 在指定位置将指定 Collection 中的所有元素插入到此向量中。
5	void addElement(Object obj) 将指定的元件添加到此向量的末尾，将其大小增加 1。
6	int capacity() 傳回此向量的目前容量。
7	void clear() 從此向量中移除所有元素。
8	Object clone() 傳回向量的一個副本。
9	boolean contains(Object elem) 如果此向量包含指定的元素，則傳回 true。
10	boolean containsAll(Collection c) 如果此向量包含指定 Collection 中的所有元素，則傳回 true。
11	void copyInto(Object[] anArray) 将此向量的元件複制到指定的數組中。
12	Object elementAt(int index) 傳回指定索引處的元件。
13	Enumeration elements() 傳回此向量的元件的枚舉。
14	void ensureCapacity(int minCapacity) 增加此向量的容量（如有必要），以確定其至少能夠儲存最小容量參數指定的元件數。
15	boolean equals(Object o) 比較指定對象與此向量的相等性。
16	Object firstElement() 傳回此向量的第一個元件（位于索引 0) 處的項）。
17	Object get(int index) 傳回向量中指定位置的元素。
18	int hashCode() 傳回此向量的哈希碼值。
19	int indexOf(Object elem) 傳回此向量中第一次出現的指定元素的索引，如果此向量不包含該元素，則傳回 -1。
20	int indexOf(Object elem, int index) 傳回此向量中第一次出現的指定元素的索引，從 index 處正向搜尋，如果未找到該元素，則傳回 -1。
21	void insertElementAt(Object obj, int index) 将指定對象作為此向量中的元件插入到指定的 index 處。
22	boolean isEmpty() 測試此向量是否不包含元件。
23	Object lastElement() 傳回此向量的最後一個元件。
24	int lastIndexOf(Object elem) 傳回此向量中最後一次出現的指定元素的索引；如果此向量不包含該元素，則傳回 -1。
25	int lastIndexOf(Object elem, int index) 傳回此向量中最後一次出現的指定元素的索引，從 index 處逆向搜尋，如果未找到該元素，則傳回 -1。
26	Object remove(int index) 移除此向量中指定位置的元素。
27	boolean remove(Object o) 移除此向量中指定元素的第一個比對項，如果向量不包含該元素，則元素保持不變。
28	boolean removeAll(Collection c) 從此向量中移除包含在指定 Collection 中的所有元素。
29	void removeAllElements() 從此向量中移除全部元件，并将其大小設定為零。
30	boolean removeElement(Object obj) 從此向量中移除變量的第一個（索引最小的）比對項。
31	void removeElementAt(int index) 删除指定索引處的元件。
32	protected void removeRange(int fromIndex, int toIndex) 從此 List 中移除其索引位于 fromIndex（包括）與 toIndex（不包括）之間的所有元素。
33	boolean retainAll(Collection c) 在此向量中僅保留包含在指定 Collection 中的元素。
34	Object set(int index, Object element) 用指定的元素替換此向量中指定位置處的元素。
35	void setElementAt(Object obj, int index) 将此向量指定 index 處的元件設定為指定的對象。
36	void setSize(int newSize) 設定此向量的大小。
37	int size() 傳回此向量中的元件數。
38	List subList(int fromIndex, int toIndex) 傳回此 List 的部分視圖，元素範圍為從 fromIndex（包括）到 toIndex（不包括）。
39	Object[] toArray() 傳回一個數組，包含此向量中以恰當順序存放的所有元素。
40	Object[] toArray(Object[] a) 傳回一個數組，包含此向量中以恰當順序存放的所有元素；傳回數組的運作時類型為指定數組的類型。
41	String toString() 傳回此向量的字元串表示形式，其中包含每個元素的 String 表示形式。
42	void trimToSize() 對此向量的容量進行微調，使其等于向量的目前大小。

執行個體

下面的程式說明這個集合所支援的幾種方法：

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);     // 大小為3，增量為2 
      System.out.println("Initial size: " + v.size());     // 向量元件數
      System.out.println("Initial capacity: " +
      v.capacity());                             // 目前容量
      v.addElement(new Integer(1));       // 添加元素：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定義的所有方法，也定義了自己的一些方法。

Stack()

除了由Vector定義的所有方法，自己也定義了一些方法：

序号	方法描述
1	boolean empty() 測試堆棧是否為空。
2	Object peek( ) 檢視堆棧頂部的對象，但不從堆棧中移除它。
3	Object pop( ) 移除堆棧頂部的對象，并作為此函數的值傳回該對象。
4	Object push(Object element) 把項壓入堆棧頂部。
5	int search(Object element) 傳回對象在堆棧中的位置，以 1 為基數。

執行個體

下面的程式說明這個集合所支援的幾種方法

import java.util.*;
 
public class StackDemo {
 
    static void showpush(Stack<Integer> st, int a) {
        st.push(new Integer(a));     // 将元素 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類相似。

給出鍵和值，你就可以将值存儲在Dictionary對象中。一旦該值被存儲，就可以通過它的鍵來擷取它。是以和Map一樣， Dictionary 也可以作為一個鍵/值對清單。

Dictionary定義的抽象方法如下表所示：

序号	方法描述
1	Enumeration elements( ) 傳回此 dictionary 中值的枚舉。
2	Object get(Object key) 傳回此 dictionary 中該鍵所映射到的值。
3	boolean isEmpty( ) 測試此 dictionary 是否不存在從鍵到值的映射。
4	Enumeration keys( ) 傳回此 dictionary 中的鍵的枚舉。
5	Object put(Object key, Object value) 将指定 key 映射到此 dictionary 中指定 value。
6	Object remove(Object key) 從此 dictionary 中移除 key （及其相應的 value）。
7	int size( ) 傳回此 dictionary 中條目（不同鍵）的數量。

Dictionary類已經過時了。在實際開發中，你可以實作Map接口來擷取鍵/值的存儲功能。

Java Map 接口

Map接口中鍵和值一一映射. 可以通過鍵來擷取值。

給定一個鍵和一個值，你可以将該值存儲在一個Map對象. 之後，你可以通過鍵來通路對應的值。
當通路的值不存在的時候，方法就會抛出一個NoSuchElementException異常.
當對象的類型和Map裡元素類型不相容的時候，就會抛出一個 ClassCastException異常。
當在不允許使用Null對象的Map中使用Null對象，會抛出一個NullPointerException 異常。
當嘗試修改一個隻讀的Map時，會抛出一個UnsupportedOperationException異常。
放入Map對象中的鍵值對是無序的。

序号	方法描述
1	void clear( ) 從此映射中移除所有映射關系（可選操作）。
2	boolean containsKey(Object k) 如果此映射包含指定鍵的映射關系，則傳回 true。
3	boolean containsValue(Object v) 如果此映射将一個或多個鍵映射到指定值，則傳回 true。
4	Set entrySet( ) 傳回此映射中包含的映射關系的 Set 視圖。
5	boolean equals(Object obj) 比較指定的對象與此映射是否相等。
6	Object get(Object k) 傳回指定鍵所映射的值；如果此映射不包含該鍵的映射關系，則傳回 null。
7	int hashCode( ) 傳回此映射的哈希碼值。
8	boolean isEmpty( ) 如果此映射未包含鍵-值映射關系，則傳回 true。
9	Set keySet( ) 傳回此映射中包含的鍵的 Set 視圖。
10	Object put(Object k, Object v) 将指定的值與此映射中的指定鍵關聯（可選操作）。
11	void putAll(Map m) 從指定映射中将所有映射關系複制到此映射中（可選操作）。
12	Object remove(Object k) 如果存在一個鍵的映射關系，則将其從此映射中移除（可選操作）。
13	int size( ) 傳回此映射中的鍵-值映射關系數。
14	Collection values( ) 傳回此映射中包含的值的 Collection 視圖。

執行個體

下面的例子來解釋Map的功能

import java.util.*;

public class CollectionsDemo {

   public static void main(String[] args) {
      Map m1 = new HashMap();        // Map對象
      m1.put("Zara", "8");           // 插入鍵，值對
      m1.put("Mahnaz", "31");
      m1.put("Ayan", "12");
      m1.put("Daisy", "14");
      System.out.println();
      System.out.println(" Map Elements");
      System.out.print("\t" + m1);
   }
}

// Map Elements
        {Mahnaz=31, Ayan=12, Daisy=14, Zara=8}

哈希表（Hashtable）

Hashtable類提供了一種在使用者定義鍵結構的基礎上來組織資料的手段。

例如，在位址清單的哈希表中，你可以根據郵政編碼作為鍵來存儲和排序資料，而不是通過人名。

哈希表鍵的具體含義完全取決于哈希表的使用情景和它包含的資料。

Hashtable是原始的java.util的一部分，是一個Dictionary具體的實作。

然而，Java 2 重構的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)

Hashtable中除了從Map接口中定義的方法外，還定義了以下方法：

序号	方法描述
1	void clear( ) 将此哈希表清空，使其不包含任何鍵。
2	Object clone( ) 建立此哈希表的淺表副本。
3	boolean contains(Object value) 測試此映射表中是否存在與指定值關聯的鍵。
4	boolean containsKey(Object key) 測試指定對象是否為此哈希表中的鍵。
5	boolean containsValue(Object value) 如果此 Hashtable 将一個或多個鍵映射到此值，則傳回 true。
6	Enumeration elements( ) 傳回此哈希表中的值的枚舉。
7	Object get(Object key) 傳回指定鍵所映射到的值，如果此映射不包含此鍵的映射，則傳回 null. 更确切地講，如果此映射包含滿足 (key.equals(k)) 的從鍵 k 到值 v 的映射，則此方法傳回 v；否則，傳回 null。
8	boolean isEmpty( ) 測試此哈希表是否沒有鍵映射到值。
9	Enumeration keys( ) 傳回此哈希表中的鍵的枚舉。
10	Object put(Object key, Object value) 将指定 key 映射到此哈希表中的指定 value。
11	void rehash( ) 增加此哈希表的容量并在内部對其進行重組，以便更有效地容納和通路其元素。
12	Object remove(Object key) 從哈希表中移除該鍵及其相應的值。
13	int size( ) 傳回此哈希表中的鍵的數量。
14	String toString( ) 傳回此 Hashtable 對象的字元串表示形式，其形式為 ASCII 字元 ", " （逗号加空格）分隔開的、括在括号中的一組條目。

執行個體

import java.util.*;

public class HashTableDemo {

   public static void main(String args[]) {
      // Create a hash map
      Hashtable balance = new Hashtable();     // 哈希表對象
      Enumeration names;                       // 枚舉類型的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 定義如下執行個體變量.這個變量持有一個Properties對象相關的預設屬性清單。

Properties defaults;

Properties類定義了兩個構造方法. 第一個構造方法沒有預設值。

Properties()

第二個構造方法使用propDefault 作為預設值。兩種情況下，屬性清單都為空：

Properties(Properties propDefault)

除了從Hashtable中所定義的方法，Properties定義了以下方法：

序号	方法描述
1	String getProperty(String key) 用指定的鍵在此屬性清單中搜尋屬性。
2	String getProperty(String key, String defaultProperty) 用指定的鍵在屬性清單中搜尋屬性。
3	void list(PrintStream streamOut) 将屬性清單輸出到指定的輸出流。
4	void list(PrintWriter streamOut) 将屬性清單輸出到指定的輸出流。
5	void load(InputStream streamIn) throws IOException 從輸入流中讀取屬性清單（鍵和元素對）。
6	Enumeration propertyNames( ) 按簡單的面向行的格式從輸入字元流中讀取屬性清單（鍵和元素對）。
7	Object setProperty(String key, String value) 調用 Hashtable 的方法 put。
8	void store(OutputStream streamOut, String description) 以适合使用 load(InputStream)方法加載到 Properties 表中的格式，将此 Properties 表中的屬性清單（鍵和元素對）寫入輸出流。

執行個體

下面的程式說明這個資料結構支援的幾個方法：

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.
*/

Java進階學習之路之篇一（java資料結構）Java 資料結構Java Map 接口

Java 資料結構

枚舉（Enumeration）

執行個體

位集合（BitSet）

執行個體

向量（Vector）

執行個體

棧（Stack）

執行個體

字典（Dictionary）

Java Map 接口

執行個體

哈希表（Hashtable）

執行個體

屬性（Properties）

執行個體

繼續閱讀

ClassLoader基礎

JAVA進階程式設計之線程池

JDK8-Lambda練習(二)

IO流File類的使用IO流原理及流的分類節點流(或檔案流)緩沖流轉換流标準輸入、輸出流列印流資料流對象流随機存取檔案流

線程池和阻塞隊列

Java進階學習之路之篇十三（反射、注解）JAVA 反射JAVA Annotation 注解

類庫使用案例分析

《java多線程程式設計核心技術》筆記

集合輸出

Java集合-Collection一、集合架構的概述二、集合架構

檔案（二） IO流(FileReader FileWriter)

别名現象别名現象解釋

JNI技術實踐小結

JDK8-Optional容器(八)

JVM：Java記憶體區域與記憶體溢出

java單例和靜态類差別