Java&&持有對象(容器小結)

如果一個程序只包含固定數量的且其生命期都是已知的對象，那麼這是一個非常簡單的程序。

-------<Thinking in Java>

通常，程序總是根據運行時才知道的某些條件去創建新對象。對象數量，對象類型尚且不能確定。爲了解決這個問題，滿足程序員需要在任意時刻和任意位置創建任意數量對象的要求。Java實用類庫提供了一套相當完整的容器類來解決這個問題(因爲數組受到固定尺寸的左右)。其中基本的類型是List，Set，Queue和Map。這些對象類型也稱爲集合類，但由於java的類庫中實用了collection這個名字來指代類庫的一個特殊子集，所以我使用了範圍更廣的術語“容器”稱呼他們。

11.1 泛型和類型安全的容器

       要想定義用來保存Apple對象的ArrayList，你可以申明ArrayList<Apple>，而不僅僅只是ArrayList，其中尖括號括起來的是類型參數（可以有多個），它指定了這個容器實例可以保存的類型。此時將元素從List中取出來時，類型轉換也不再是必須的了。因爲List知道它保存的是什麼類型，因此它會在get()時替你執行轉型。

11.2 基本概念

        容器類類型庫的用途是“保存對象”，並將其劃分爲兩個不同的概念：

        1）Collection：一個獨立元素的序列，這些元素都服從一條或多條規則。

         2）Map：一組成對的“鍵值對”對象，允許你使用鍵來查找值。

名稱	類型	實現	優點	缺點	排序	可重複	迭代性	同步
Iterable	接口				F	T	T	F
Collection	接口				F	T	T	F
Queue	接口				F	T	T	F
PriorityQueue		堆（一種二叉樹）	優先級隊列		T	T	T	F
List	接口	按索引排序			T	T	T	F
LinkedList	類	雙向循環鏈表			T	T	T	F
ArrayList	類	數組	查找	增刪	T	T	T	F
Vector	類	數組	增刪	查找	T	T	T	T
Stack	類	棧			T	T	T	T
Set	接口				F	F	T	F
TreeSet	類				T	F	T	F
HashSet	類				F	F	T	F
Map	接口				F	F	T	F
HashMap	類		查找		F	F	T	F
TreeMap	類		排序		T	F	T	F
HashTable					F	F	T	T
Properties		HashTable的子類，表示了一個持久的屬性集。

11.2.1 Collection接口（省略常用的方法）

boolean add(Object obj) 添加一個Object元素
boolean addAll(Collection c)
boolean contains(Object obj)  判斷obj是否是調用類集的一個元素（屬於）
boolean containsAll(Collection c)  判斷c是否是調用類集的子集（包含）
boolean equals(Collection c) 判斷c是否與調用類集相等
int hashCode() 返回調用類集的hash碼
Iterator iterator() 返回調用類集的迭代程序
boolean removeAll(Collection c) 從調用類集中去掉所有c中包含的元素（差集）
boolean retainAll(Collection c) 從調用類集中去掉包含在c中以外的元素（補集）
Object[] toArray() 返回類集的元素組成的數組

void clear()
boolean isEmpty()
int size()

//類集包含一個add(Object obj)方法，因此可以包含任意Object數據，但是不能直接存儲：int，char,double等數據。可以使用下面的方法實現：
ArrayList a=new ArrayList();
a.add(new Integer(1));
a.add(new Integer(2));
//……

//當類集不能被修改時，可能引發 UnsupportedOperationException異常。企圖將一個不兼容的對象加入到一個類集中時可能引發ClassCastException//異常。

11.3 添加一組元素

 

//: holding/AddingGroups.java
// Adding groups of elements to Collection objects.
import java.util.*;

public class AddingGroups {
  public static void main(String[] args) {
    Collection<Integer> collection =
      new ArrayList<Integer>(Arrays.asList(1, 2, 3, 4, 5));
    Integer[] moreInts = { 6, 7, 8, 9, 10 };
    collection.addAll(Arrays.asList(moreInts));
    // Runs significantly faster, but you can't
    // construct a Collection this way:
    Collections.addAll(collection, 11, 12, 13, 14, 15);
    Collections.addAll(collection, moreInts);
    // Produces a list "backed by" an array:
    List<Integer> list = Arrays.asList(16, 17, 18, 19, 20);
    list.set(1, 99); // OK -- modify an element
    // list.add(21); // Runtime error because the
                     // underlying array cannot be resized.
  }
} ///:~

    你也可以直接使用Arrays.asList()的輸出，將其當作List，但是在這種情況下，其底層表示的是數組，因此不能調整尺寸。
    Arrays.asList()方法的限制是它對所產生的List的類型做出了最理想的假設，而並沒有注意你會對它賦予什麼樣的類型。

//: holding/AsListInference.java
// Arrays.asList() makes its best guess about type.
import java.util.*;

class Snow {}
class Powder extends Snow {}
class Light extends Powder {}
class Heavy extends Powder {}
class Crusty extends Snow {}
class Slush extends Snow {}

public class AsListInference {
  public static void main(String[] args) {
    List<Snow> snow1 = Arrays.asList(
      new Crusty(), new Slush(), new Powder());

    // Won't compile:
    // List<Snow> snow2 = Arrays.asList(
    //   new Light(), new Heavy());
    // Compiler says:
    // found   : java.util.List<Powder>
    // required: java.util.List<Snow>

    // Collections.addAll() doesn't get confused:
    List<Snow> snow3 = new ArrayList<Snow>();
    Collections.addAll(snow3, new Light(), new Heavy());

    // Give a hint using an
    // explicit type argument specification:
    List<Snow> snow4 = Arrays.<Snow>asList(
       new Light(), new Heavy());
  }
} ///:~

11.4 容器的打印

//: holding/PrintingContainers.java
// Containers print themselves automatically.
import java.util.*;
import static net.mindview.util.Print.*;

public class PrintingContainers {
  static Collection fill(Collection<String> collection) {
    collection.add("rat");
    collection.add("cat");
    collection.add("dog");
    collection.add("dog");
    return collection;
  }
  static Map fill(Map<String,String> map) {
    map.put("rat", "Fuzzy");
    map.put("cat", "Rags");
    map.put("dog", "Bosco");
    map.put("dog", "Spot");
    return map;
  }
  public static void main(String[] args) {
    print(fill(new ArrayList<String>()));
    print(fill(new LinkedList<String>()));
    print(fill(new HashSet<String>()));
    print(fill(new TreeSet<String>()));
    print(fill(new LinkedHashSet<String>()));
    print(fill(new HashMap<String,String>()));
    print(fill(new TreeMap<String,String>()));
    print(fill(new LinkedHashMap<String,String>()));
  }
} /* Output:
[rat, cat, dog, dog]
[rat, cat, dog, dog]
[dog, cat, rat]
[cat, dog, rat]
[rat, cat, dog]
{dog=Spot, cat=Rags, rat=Fuzzy}
{cat=Rags, dog=Spot, rat=Fuzzy}
{rat=Fuzzy, cat=Rags, dog=Spot}
*///:~

    ArrayList和LinkedList都是List類型，從輸出可以看出，它們都是按照被插入的順序保存元素。兩者不同之處不僅在於執行某些類型的操作時的性能，而且LinkedList包含的操作也多餘ArrayList。

       HashSet，TreeSet和LinkedHashSet都是Set類型，輸出顯示在Set中，每個相同的項只保存一次，但是輸出也顯示了不同的Set實現存儲元素的方式也不同。

       你不需要指定Map的尺寸，因爲它會自動地調整尺寸。

       HashMap提供了最快的查找技術，也沒有按照任何明顯的順序來保存其元素。TreeMap按照比較結果的升序保存鍵，而LinkedHashMap則按照插入順序保存鍵，同時還保留了HashMap的查詢速度。

11.5 List

List接口（從Collection繼承而來，使用基於0的下標）

void add(int index,Object obj) 插入點以後的元素將後移
boolean addAll(int index,Collection c) 如果調用列表改變了，返回true,否則返回false
Object get(int index)
int indexOf(Object obj) 返回obj對象在列表中的索引，不存在返回-1
int lastIndexOf(Object obj) 返回obj在列表中的最後一個實例的下標，不存在返回-1
ListIterator listIterator()
ListIterator listIterator(int index) 返回index開始的迭代程序
Object set(int index,Object obj) 對列表index處的值進行修改
List subList(int start,int end) 從start到end-1

11.6 迭代器

iterator實現Iterator接口或者ListIterator接口。
Iterator接口

boolean hasNext()
Object next() 如果沒有下一個元素則引發NoSuchElementException異常。
void remove() 刪除當前元素，如果試圖在調用next()方法後調用remove()方法則引發IllegalStateException異常。
 ListIterator接口
void add(Object obj) 將一個元素插入到當前元素之前，調用next()方法將返回該元素。
boolean hasNext()
boolean hasPrevious()
Object next() 如果不存在引發NoSuchElementException
int nextIndex() 如果不存在返回列表的大小
void remove()
void set(Object obj) 修改當前元素

public void test1() {
        ArrayList al = new ArrayList();
        for (int i = 1; i < 10; i ) {
            al.add("ArrayList Element:" i);
        }
        Iterator itr = al.listIterator();
        while (itr.hasNext()) {
            Object obj = itr.next();
            System.out.println(obj);
        }
    }

public void test2() {
        HashSet hs = new HashSet();
        System.out.println("HashSet");
        for (int i = 1; i < 10; i ) {
            hs.add("HashSet Element:" i);
        }
        Iterator itr = hs.iterator();
        while (itr.hasNext()) {
            Object obj = itr.next();
            System.out.println(obj);
        }
    }

    public void test3() {
        TreeSet ts = new TreeSet();
        System.out.println("TreeSet");
        for (int i = 1; i < 10; i ) {
            ts.add("TreeSet Element:" i);
        }
        Iterator itr = ts.iterator();
        while (itr.hasNext()) {
            Object obj = itr.next();
            System.out.println(obj);
        }
    }

    public void test4()
    {
        HashMap hm=new HashMap();
        for ( int i=0;i<10;i )
        {
            hm.put("item" i,"value" i);
        }

        Set set=hm.entrySet();
        Iterator itr=set.iterator();
        while (itr.hasNext())
        {
            Map.Entry me=(Map.Entry)itr.next();

11.7 LinkedList

         LinkedList還添加了可以使其用作棧、隊列或雙端隊列的方法。

11.8 Stack

//: net/mindview/util/Stack.java
// Making a stack from a LinkedList.
package net.mindview.util;
import java.util.LinkedList;

public class Stack<T> {
  private LinkedList<T> storage = new LinkedList<T>();
  public void push(T v) { storage.addFirst(v); }
  public T peek() { return storage.getFirst(); }
  public T pop() { return storage.removeFirst(); }
  public boolean empty() { return storage.isEmpty(); }
  public String toString() { return storage.toString(); }
} ///:~

11.9 Set

Set接口（從Collection派生，沒有定義新的方法）

Set不允許有重複的元素,用Iterator()方法來區分重複與否。
對Set調用add（Object obj）方法，如果obj已經存在集合中，將返回false。

11.9.1 SortedSet接口

Comparator comparator() 返回調用排序集合的比較函數，如果改集合使用自然順序，則返回null
Object first() 返回被排序集合的第一個元素
SortedSet headSet(Object end) 返回一個包含小於end元素的SortedSet
Object last() 返回調用排序集合的最後一個元素
SortedSet subSet(Object start,Object end) 包括從start到end-1
SortedSet tailSet(Object start) 返回包含大於等於start的元素
 ArrayList擴展AstractList類，並執行List接口。ArrayList支持動態長度的數組。
LinkList擴展了AbstractSequentialList，執行List接口。提供連接列表。
HashSet擴展AbstractSet實現Set接口，元素沒有順序。對於大集合提供常量級基本操作。
TreeSet使用樹來存儲的Set，對象按升序存儲。訪問和檢索非常快。

11.10 Map

(1) 添加、刪除操作：
　　Object put(Object key, Object value): 將互相關聯的一個關鍵字與一個值放入該映像。如果該關鍵字已經存在，那麼與此關鍵字相關的新值將取代舊值。方法返回關鍵字的舊值，如果關鍵字原先並不存在，則返回null
　　Object remove(Object key): 從映像中刪除與key相關的映射
　　void putAll(Map t): 將來自特定映像的所有元素添加給該映像
　　void clear(): 從映像中刪除所有映射
　　“鍵和值都可以爲null。但是，您不能把Map作爲一個鍵或值添加給自身。”
　　(2) 查詢操作：
　　Object get(Object key): 獲得與關鍵字key相關的值，並且返回與關鍵字key相關的對象，如果沒有在該映像中找到該關鍵字，則返回null
　　boolean containsKey(Object key): 判斷映像中是否存在關鍵字key
　　boolean containsValue(Object value): 判斷映像中是否存在值value
　　int size(): 返回當前映像中映射的數量
　　boolean isEmpty() ：判斷映像中是否有任何映射
　　(3) 視圖操作 ：處理映像中鍵/值對組
　　Set keySet(): 返回映像中所有關鍵字的視圖集
　　“因爲映射中鍵的集合必須是唯一的，您用Set支持。你還可以從視圖中刪除元素，同時，關鍵字和它相關的值將從源映像中被刪除，但是你不能添加任何元素。”
　　Collection values():返回映像中所有值的視圖集
　　“因爲映射中值的集合不是唯一的，您用Collection支持。你還可以從視圖中刪除元素，同時，值和它的關鍵字將從源映像中被刪除，但是你不能添加任何元素。”
　　Set entrySet(): 返回Map.Entry對象的視圖集，即映像中的關鍵字/值對
　　“因爲映射是唯一的，您用Set支持。你還可以從視圖中刪除元素，同時，這些元素將從源映像中被刪除，但是你不能添加任何元素。”

11.11 Queue

11.12 Collection和Iterator

11.13 Foreach與迭代器

        之所以能夠工作，是因爲java SE5引入了新的被稱爲Iterable的接口，該接口包含一個能夠產生Iterator的iterator()方法，並且Iterable接口被foreach用來在序列中移動。因此如果你創建了任何實現Iterable的類，都可以將它用於foreach語句中：

//: holding/IterableClass.java
// Anything Iterable works with foreach.
import java.util.*;

public class IterableClass implements Iterable<String> {
  protected String[] words = ("And that is how " +
    "we know the Earth to be banana-shaped.").split(" ");
  public Iterator<String> iterator() {
    return new Iterator<String>() {
      private int index = 0;
      public boolean hasNext() {
        return index < words.length;
      }
      public String next() { return words[index++]; }
      public void remove() { // Not implemented
        throw new UnsupportedOperationException();
      }
    };
  }
  public static void main(String[] args) {
    for(String s : new IterableClass())
      System.out.print(s + " ");
  }
} /* Output:
And that is how we know the Earth to be banana-shaped.
*///:~

11.4 總結

簡單容器分類：

補充：來自轉載

Java容器集合類的區別用法

Set,List,Map,Vector,ArrayList的區別

JAVA的容器---List,Map,Set 
Collection 
├List 
│├LinkedList 
│├ArrayList 
│└Vector 
│　└Stack 
└Set 
Map 
├Hashtable 
├HashMap 
└WeakHashMap

Collection接口 
　　Collection是最基本的集合接口，一個Collection代表一組Object，即Collection的元素（Elements）。一些 Collection允許相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接繼承自Collection的類，Java SDK提供的類都是繼承自Collection的“子接口”如List和Set。 
　　所有實現Collection接口的類都必須提供兩個標準的構造函數：無參數的構造函數用於創建一個空的Collection，有一個 Collection參數的構造函數用於創建一個新的Collection，這個新的Collection與傳入的Collection有相同的元素。後一個構造函數允許用戶複製一個Collection。 
　　如何遍歷Collection中的每一個元素？不論Collection的實際類型如何，它都支持一個iterator()的方法，該方法返回一個迭代子，使用該迭代子即可逐一訪問Collection中每一個元素。典型的用法如下： 
　　　　Iterator it = collection.iterator(); // 獲得一個迭代子 
　　　　while(it.hasNext()) { 
　　　　　　Object obj = it.next(); // 得到下一個元素 
　　　　} 
　　由Collection接口派生的兩個接口是List和Set。

List接口 
　　List是有序的Collection，使用此接口能夠精確的控制每個元素插入的位置。用戶能夠使用索引（元素在List中的位置，類似於數組下標）來訪問List中的元素，這類似於Java的數組。 
和下面要提到的Set不同，List允許有相同的元素。 
　　除了具有Collection接口必備的iterator()方法外，List還提供一個listIterator()方法，返回一個 ListIterator接口，和標準的Iterator接口相比，ListIterator多了一些add()之類的方法，允許添加，刪除，設定元素，還能向前或向後遍歷。 
　　實現List接口的常用類有LinkedList，ArrayList，Vector和Stack。

LinkedList類 
　　LinkedList實現了List接口，允許null元素。此外LinkedList提供額外的get，remove，insert方法在 LinkedList的首部或尾部。這些操作使LinkedList可被用作堆棧（stack），隊列（queue）或雙向隊列（deque）。 
　　注意LinkedList沒有同步方法。如果多個線程同時訪問一個List，則必須自己實現訪問同步。一種解決方法是在創建List時構造一個同步的List： 
　　　　List list = Collections.synchronizedList(new LinkedList(...));

ArrayList類 
　　ArrayList實現了可變大小的數組。它允許所有元素，包括null。ArrayList沒有同步。 
size，isEmpty，get，set方法運行時間爲常數。但是add方法開銷爲分攤的常數，添加n個元素需要O(n)的時間。其他的方法運行時間爲線性。 
　　每個ArrayList實例都有一個容量（Capacity），即用於存儲元素的數組的大小。這個容量可隨着不斷添加新元素而自動增加，但是增長算法並沒有定義。當需要插入大量元素時，在插入前可以調用ensureCapacity方法來增加ArrayList的容量以提高插入效率。 
　　和LinkedList一樣，ArrayList也是非同步的（unsynchronized）。

Vector類 
　　Vector非常類似ArrayList，但是Vector是同步的。由Vector創建的Iterator，雖然和ArrayList創建的 Iterator是同一接口，但是，因爲Vector是同步的，當一個Iterator被創建而且正在被使用，另一個線程改變了Vector的狀態（例如，添加或刪除了一些元素），這時調用Iterator的方法時將拋出ConcurrentModificationException，因此必須捕獲該異常。

Stack 類 
　　Stack繼承自Vector，實現一個後進先出的堆棧。Stack提供5個額外的方法使得Vector得以被當作堆棧使用。基本的push和pop 方法，還有peek方法得到棧頂的元素，empty方法測試堆棧是否爲空，search方法檢測一個元素在堆棧中的位置。Stack剛創建後是空棧。

Set接口 
　　Set是一種不包含重複的元素的Collection，即任意的兩個元素e1和e2都有e1.equals(e2)=false，Set最多有一個null元素。 
　　很明顯，Set的構造函數有一個約束條件，傳入的Collection參數不能包含重複的元素。 
　　請注意：必須小心操作可變對象（Mutable Object）。如果一個Set中的可變元素改變了自身狀態導致Object.equals(Object)=true將導致一些問題。

Map接口 
　　請注意，Map沒有繼承Collection接口，Map提供key到value的映射。一個Map中不能包含相同的key，每個key只能映射一個 value。Map接口提供3種集合的視圖，Map的內容可以被當作一組key集合，一組value集合，或者一組key-value映射。

Hashtable類 
　　Hashtable繼承Map接口，實現一個key-value映射的哈希表。任何非空（non-null）的對象都可作爲key或者value。 
　　添加數據使用put(key, value)，取出數據使用get(key)，這兩個基本操作的時間開銷爲常數。 
Hashtable通過initial capacity和load factor兩個參數調整性能。通常缺省的load factor 0.75較好地實現了時間和空間的均衡。增大load factor可以節省空間但相應的查找時間將增大，這會影響像get和put這樣的操作。 
使用Hashtable的簡單示例如下，將1，2，3放到Hashtable中，他們的key分別是”one”，”two”，”three”： 
　　　　Hashtable numbers = new Hashtable(); 
　　　　numbers.put(“one”, new Integer(1)); 
　　　　numbers.put(“two”, new Integer(2)); 
　　　　numbers.put(“three”, new Integer(3)); 
　　要取出一個數，比如2，用相應的key： 
　　　　Integer n = (Integer)numbers.get(“two”); 
　　　　System.out.println(“two = ” + n); 
　　由於作爲key的對象將通過計算其散列函數來確定與之對應的value的位置，因此任何作爲key的對象都必須實現hashCode和equals方法。hashCode和equals方法繼承自根類Object，如果你用自定義的類當作key的話，要相當小心，按照散列函數的定義，如果兩個對象相同，即obj1.equals(obj2)=true，則它們的hashCode必須相同，但如果兩個對象不同，則它們的hashCode不一定不同，如果兩個不同對象的hashCode相同，這種現象稱爲衝突，衝突會導致操作哈希表的時間開銷增大，所以儘量定義好的hashCode()方法，能加快哈希表的操作。 
　　如果相同的對象有不同的hashCode，對哈希表的操作會出現意想不到的結果（期待的get方法返回null），要避免這種問題，只需要牢記一條：要同時複寫equals方法和hashCode方法，而不要只寫其中一個。 
　　Hashtable是同步的。

HashMap類 
　　HashMap和Hashtable類似，不同之處在於HashMap是非同步的，並且允許null，即null value和null key。，但是將HashMap視爲Collection時（values()方法可返回Collection），其迭代子操作時間開銷和HashMap 的容量成比例。因此，如果迭代操作的性能相當重要的話，不要將HashMap的初始化容量設得過高，或者load factor過低。

WeakHashMap類 
　　WeakHashMap是一種改進的HashMap，它對key實行“弱引用”，如果一個key不再被外部所引用，那麼該key可以被GC回收。

總結 
　　如果涉及到堆棧，隊列等操作，應該考慮用List，對於需要快速插入，刪除元素，應該使用LinkedList，如果需要快速隨機訪問元素，應該使用ArrayList。 
　　如果程序在單線程環境中，或者訪問僅僅在一個線程中進行，考慮非同步的類，其效率較高，如果多個線程可能同時操作一個類，應該使用同步的類。 
　　要特別注意對哈希表的操作，作爲key的對象要正確複寫equals和hashCode方法。 
　　儘量返回接口而非實際的類型，如返回List而非ArrayList，這樣如果以後需要將ArrayList換成LinkedList時，客戶端代碼不用改變。這就是針對抽象編程。

Java 集合類 map set list arraylist hashmap hashtable(轉)

Vector的方法都是同步的(Synchronized),是線程安全的(thread-safe)，而ArrayList的方法不是，由於線程的同步必然要影響性能，因此,ArrayList的性能比Vector好。 
當Vector或ArrayList中的元素超過它的初始大小時,Vector會將它的容量翻倍,而ArrayList只增加50%的大小，這樣,ArrayList就有利於節約內存空間。 
Hashtable和HashMap   
它們的性能方面的比較類似 Vector和ArrayList，比如Hashtable的方法是同步的,而HashMap的不是。 
ArrayList和LinkedList   
對 於處理一列數據項,Java提供了兩個類ArrayList和LinkedList,ArrayList的內部實現是基於內部數組Object[],所以 從概念上講,它更象數組，但LinkedList的內部實現是基於一組連接的記錄,所以,它更象一個鏈表結構，所以,它們在性能上有很大的差別。   
（1） 從上面的分析可知,在ArrayList的前面或中間插入數據時,你必須將其後的所有數據相應的後移,這樣必然要花費較多時間，所以,當你的操作是在一列 數據的後面添加數據而不是在前面或中間,並且需要隨機地訪問其中的元素時,使用ArrayList會提供比較好的性能。   
（2）而訪問鏈表中的某個元素時,就必須從鏈表的一端開始沿着連接方向一個一個元素地去查找,直到找到所需的元素爲止，所以,當你的操作是在一列數據的前面或中間添加或刪除數據,並且按照順序訪問其中的元素時,就應該使用LinkedList了。   
（3）如果在編程中,1，2兩種情形交替出現,這時,你可以考慮使用List這樣的通用接口,而不用關心具體的實現，在具體的情形下,它的性能由具體的實現來保證。 
設置集合類的初始大小 
在Java 集合框架中的大部分類的大小是可以隨着元素個數的增加而相應的增加的，我們似乎不用關心它的初始大小,但如果我們考慮類的性能問題時,就一定要考慮儘可能 地設置好集合對象的初始大小,這將大大提高代碼的性能，比如,Hashtable缺省的初始大小爲101,載入因子爲0.75,即如果其中的元素個數超過 75個,它就必須增加大小並重新組織元素，所以,如果你知道在創建一個新的Hashtable對象時就知道元素的確切數目如爲110,那麼,就應將其初始 大小設爲110/0.75=148,這樣,就可以避免重新組織內存並增加大小。 
特別要理解的： 
Hashtable類 
　　Hashtable繼承Map接口，實現一個key-value映射的哈希表。任何非空（non-null）的對象都可作爲key或者value。 
　　添加數據使用put(key, value)，取出數據使用get(key)，這兩個基本操作的時間開銷爲常數。 
Hashtable 通過initial capacity和load factor兩個參數調整性能。通常缺省的load factor 0.75較好地實現了時間和空間的 均衡。增大load factor可以節省空間但相應的查找時間將增大，這會影響像get和put這樣的操作。 
使用Hashtable的簡單示例如下，將1，2，3放到Hashtable中，他們的key分別是”one”，”two”，”three”： 
　　　　Hashtable numbers = new Hashtable(); 
　　　　numbers.put(“one”, new Integer(1)); 
　　　　numbers.put(“two”, new Integer(2)); 
　　　　numbers.put(“three”, new Integer(3)); 
　　要取出一個數，比如2，用相應的key： 
　　　　Integer n = (Integer)numbers.get(“two”); 
　　　　System.out.println(“two = ” + n); 
　 　由於作爲key的對象將通過計算其散列函數來確定與之對應的value的位置，因此任何作爲key的對象都必須實現hashCode和equals方 法。hashCode和equals方法繼承自根類Object，如果你用自定義的類當作key的話，要相當小心，按照散列函數的定義，如果兩個對象相 同，即obj1.equals(obj2)=true，則它們的hashCode必須相同，但如果兩個對象不同，則它們的hashCode不一定不同，如 果兩個不同對象的hashCode相同，這種現象稱爲衝突，衝突會導致操作哈希表的時間開銷增大，所以儘量定義好的hashCode()方法，能加快哈希 表的操作。 
　　如果相同的對象有不同的hashCode，對哈希表的操作會出現意想不到的結果（期待的get方法返回null），要避免這種問題，只需要牢記一條：要同時複寫equals方法和hashCode方法，而不要只寫其中一個。 
　　Hashtable是同步的。 
HashMap類 
　 　HashMap和Hashtable類似，不同之處在於HashMap是非同步的，並且允許null，即null value和null key。，但 是將HashMap視爲Collection時（values()方法可返回Collection），其迭代子操作時間開銷和HashMap的容量成比 例。因此，如果迭代操作的性能相當重要的話，不要將HashMap的初始化容量設得過高，或者load factor過低。 
LinkedList類 
　 　LinkedList實現了List接口，允許null元素。此外LinkedList提供額外的get，remove，insert方法在 LinkedList的首部或尾部。這些操作使LinkedList可被用作堆棧（stack），隊列（queue）或雙向隊列（deque）。 
　　注意LinkedList沒有同步方法。如果多個線程同時訪問一個List，則必須自己實現訪問同步。一種解決方法是在創建List時構造一個同步的List： 
　　　　List list = Collections.synchronizedList(new LinkedList(...)); 
ArrayList類 
　　ArrayList實現了可變大小的數組。它允許所有元素，包括null。ArrayList沒有同步。 
size，isEmpty，get，set方法運行時間爲常數。但是add方法開銷爲分攤的常數，添加n個元素需要O(n)的時間。其他的方法運行時間爲線性。 
　 　每個ArrayList實例都有一個容量（Capacity），即用於存儲元素的數組的大小。這個容量可隨着不斷添加新元素而自動增加，但是增長算法並 沒有定義。當需要插入大量元素時，在插入前可以調用ensureCapacity方法來增加ArrayList的容量以提高插入效率。 
　　和LinkedList一樣，ArrayList也是非同步的（unsynchronized）。 
Vector類 
　 　Vector非常類似ArrayList，但是Vector是同步的。由Vector創建的Iterator，雖然和ArrayList創建的 Iterator是同一接口，但是，因爲Vector是同步的，當一個Iterator被創建而且正在被使用，另一個線程改變了Vector的狀態（例 如，添加或刪除了一些元素），這時調用Iterator的方法時將拋出ConcurrentModificationException，因此必須捕獲該 異常。