一、Java 集合框架

集合框架是一個用來代表和操縱集合的統一架構。所有的集合框架都包含如下內容：

• 介面：是代表集合的抽象數據類型。介面允許集合獨立操縱其代表的細節。在面向對象的語言，介面通常形成一個層次。
• 實現（類）：是集合介面的具體實現。從本質上講，它們是可重覆使用的數據結構。
• 演算法：是實現集合介面的對象里的方法執行的一些有用的計算，例如：搜索和排序。這些演算法被稱為多態，那是因為相同的方法可以在相似的介面上有著不同的實現。

集合介面

集合實現類（集合類）

Java提供了一套實現了Collection介面的標準集合類。其中一些是具體類，這些類可以直接拿來使用，而另外一些是抽象類，提供了介面的部分實現。

標準集合類彙總於下表：

Listlist=Collections.synchronizedList(newLinkedList(...));

在前面的教程中已經討論通過java.util包中定義的類，如下所示：

import java.util.Iterator;
import java.util.List;
import java.util.ArrayList;

public class myArrayList {
    public static void main(String[] args){
        List<String> list = new ArrayList<String>();
        list.add("nick");
        list.add("jenny");
        list.add("Maria");
        
        //第一種遍歷方法使用foreach遍歷List
        for (String str : list){
            System.out.println(str);
        }
        
        //第二種遍歷，把鏈表變為數組相關的內容進行遍歷
        String[] strArray = new String[list.size()];
        list.toArray(strArray);
        for (int i=0;i<strArray.length;i++){
            System.out.println(strArray[i]);
        }
        
        //第三種遍歷 使用迭代器進行相關遍歷
        Iterator<String> ite=list.iterator();
        while (ite.hasNext()){
            System.out.println(ite.next());
        }
    }
}

package three;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class mymap {
    public static void main(String[] args){
        Map<String, String> map = new HashMap<String, String>();
        map.put("name", "nick");
        map.put("age", "18");
        map.put("single", "singleDog");
        
        //第一種：普遍使用，二次取值
        for (String key : map.keySet()){
            System.out.println(key + " " + map.get(key));
        }
        
        //通過Map.entrySet使用iterator遍歷key和value
        Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry<String, String> entry = it.next();
            System.out.println(entry.getKey() + " " + entry.getValue());
        }
        
        //第三種：推薦，尤其是容量大時
        for (Map.Entry<String, String> entry : map.entrySet()){
            System.out.println(entry.getKey() + " " + entry.getValue());
        }
        
        //通過Map.values()遍歷所有的value，但不能遍歷key
        for (String v : map.values()){
            System.out.println(v);
        }
    }
}

二、Java數據結構

在Java中的數據結構主要包括以下幾種介面和類：

• 枚舉（Enumeration）
• 位集合（BitSet）
• 向量（Vector）
• 棧（Stack）
• 字典（Dictionary）
• 哈希表（Hashtable）
• 屬性（Properties）

枚舉（Enumeration）

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

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

package three;

import java.util.Vector;
import java.util.Enumeration;

public class myEnumeration {
    public static void main(String[] args){
        Enumeration days;
        Vector dayNames = new Vector();
        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()    //第一個構造方法創建一個預設的對象
BitSet(int size)    //第二個方法允許用戶指定初始大小。所有位初始化為0。

BitSet中實現了Cloneable介面中定義的方法如下表所列：

package three;


import java.util.BitSet;

public class myBitset {
    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);
            if((i%5) != 0) bits2.set(i);
        }
        System.out.println("Initial pattern in bits1: ");
        System.out.println(bits1);    // {0, 2, 4, 6, 8, 10, 12, 14}
        System.out.println("\nInitial pattern in bits2: ");
        System.out.println(bits2);    // {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 14}
        
        // AND bits
        bits2.and(bits1);
        System.out.println("\nbits2 AND bits1: ");
        System.out.println(bits1);    // {0, 2, 4, 6, 8, 10, 12, 14}
        System.out.println(bits2);    // {2, 4, 6, 8, 12, 14}
        
        // OR bits
        bits2.or(bits1);
        System.out.println("\nbits2 OR bits1: ");
        System.out.println(bits1);    // {0, 2, 4, 6, 8, 10, 12, 14}
        System.out.println(bits2);    // {0, 2, 4, 6, 8, 10, 12, 14}
        
        // XOR bits
        bits2.xor(bits1);
        System.out.println("\nbits2 XOR bits1: ");
        System.out.println(bits1);    // {0, 2, 4, 6, 8, 10, 12, 14}
        System.out.println(bits2);    // {}
    }
}

向量（Vector）

向量（Vector）類和傳統數組非常相似，但是Vector的大小能根據需要動態的變化。

和數組一樣，Vector對象的元素也能通過索引訪問。

使用Vector類最主要的好處就是在創建對象的時候不必給對象指定大小，它的大小會根據需要動態的變化。

Vector類實現了一個動態數組。和ArrayList和相似，但是兩者是不同的：

• Vector是同步訪問的。
• Vector包含了許多傳統的方法，這些方法不屬於集合框架。

Vector主要用在事先不知道數組的大小，或者只是需要一個可以改變大小的數組的情況。

Vector類支持4種構造方法。

Vector()    //第一種構造方法創建一個預設的向量，預設大小為10
Vector(int size)    //第二種構造方法創建指定大小的向量
Vector(int size,int incr)    //第三種構造方法創建指定大小的向量，並且增量用incr指定. 增量表示向量每次增加的元素數目
Vector(Collection c)    //第四中構造方法創建一個包含集合c元素的向量

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

package three;


import java.util.*;

public class myVector {
    public static void main(String[] args){
          Vector v = new Vector(3, 2);
          System.out.println(v.size());    // 0
          System.out.println(v.capacity());    // 3
          v.addElement(new Integer(1));
          System.out.println(v.capacity());    // 3
          v.addElement(new Integer(2));
          System.out.println(v.capacity());    // 3
          v.addElement(new Integer(3));
          System.out.println(v.capacity());    // 3
          
          v.addElement(new Integer(4));
          System.out.println(v.capacity());    // 5
          v.addElement(new Double(5.45));
          System.out.println(v.capacity());    // 5
          
          v.addElement(new Double(6.08));
          v.addElement(new Integer(7));
          System.out.println(v.capacity());    // 7
          v.addElement(new Float(9.4));
          v.addElement(new Integer(10));
          System.out.println(v.capacity());    // 9
          v.addElement(new Integer(11));
          v.addElement(new Integer(12));
          System.out.println(v.capacity());    // 11
          System.out.println((Integer)v.firstElement()); // 1
          System.out.println((Integer)v.lastElement());    // 12
          
          if(v.contains(new Integer(3)))
             System.out.println("Vector contains 3.");    //true
          
          // enumerate the elements in the vector.
          Enumeration vEnum = v.elements();
          System.out.println("\nElements in vector:");
          while(vEnum.hasMoreElements())
             System.out.print(vEnum.nextElement() + " ");
               // 1 2 3 4 5.45 6.08 7 9.4 10 11 12 
          System.out.println();
    }
}

棧（Stack）

棧（Stack）實現了一個後進先出（LIFO）的數據結構。

你可以把棧理解為對象的垂直分佈的棧，當你添加一個新元素時，就將新元素放在其他元素的頂部。

當你從棧中取元素的時候，就從棧頂取一個元素。換句話說，最後進棧的元素最先被取出。

棧是Vector的一個子類，它實現了一個標準的後進先出的棧。

堆棧只定義了預設構造函數，用來創建一個空棧。 堆棧除了包括由Vector定義的所有方法，也定義了自己的一些方法。

Stack()

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

package three;

import java.util.*;

public class myStack {
       static void showpush(Stack st, int a) {
          st.push(new Integer(a));
          System.out.println("push(" + a + ")");
          System.out.println("stack: " + st);
       }

       static void showpop(Stack 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 st = new Stack();
          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定義的抽象方法如下表所示：

哈希表（Hashtable）

Hashtable類提供了一種在用戶定義鍵結構的基礎上來組織數據的手段。

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

哈希表鍵的具體含義完全取決於哈希表的使用情景和它包含的數據。

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

然而，Java 2 重構的Hashtable實現了Map介面，因此，Hashtable現在集成到了集合框架中。它和HashMap類很相似，但是它支持同步。

像HashMap一樣，Hashtable在哈希表中存儲鍵/值對。當使用一個哈希表，要指定用作鍵的對象，以及要鏈接到該鍵的值。

然後，該鍵經過哈希處理，所得到的散列碼被用作存儲在該表中值的索引。

Hashtable定義了四個構造方法。

Hashtable()
Hashtable(int size)    //創建指定大小的哈希表
Hashtable(int size,float fillRatio)    //創建一個指定大小的哈希表，並且通過fillRatio指定填充比例。填充比例必須介於0.0和1.0之間，它決定了哈希表在重新調整大小之前的充滿程度
Hashtable(Map m)    //創建一個以M中元素為初始化元素的哈希表。哈希表的容量被設置為M的兩倍。

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

package three;


import java.util.*;

public class myHashTable {
    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 定義如下實例變數.這個變數持有一個Properties對象相關的預設屬性列表。

Properties defaults;

Properties類定義了兩個構造方法。

Properties()    //第一個構造方法沒有預設值。
Properties(Properties propDefault)    //使用propDefault 作為預設值。
兩種情況下，屬性列表都為空

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

package three;


import java.util.*;

public class myProperties {
       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(