Java中 ArrayList、Vector和LinkedList 的使用和詳解（轉）

import java.util.*;

/**
* （1）ArrayList是最常用的List實現類，內部是通過數組實現的，它允許對元素進行快速隨機訪問。數組的缺點是每個元素之間不能含有“空隙”。
* 當數組大小不滿足時會增加存儲能力，將已有數組數據複製到新的存儲空間中。當從ArrayList的中間位置插入或者刪除元素時，需要對數組進行拷貝，移動，代價比較高。因此，它適合隨即查找和遍歷，不適合插入合刪除。
* （2）Vector與ArrayList一樣，也是通過數組實現的。不同的是它支持線程的同步，
* 即一時刻只有一個線程能夠寫Vector，避免多線程同時寫引起的不一致性。但實現同步需要很高的花費， 因此，訪問它比訪問ArrayList慢。
* （3）LinkedList是用鏈表結構存儲數據的，很適合數據的動態插入和刪除，隨即訪問和遍歷速度比較慢。另外，它還提供了List沒有定義的方法，專門用於操作表頭和表尾元素，可以當作堆棧、隊列和雙向隊列使用。
* （4）因爲ArrayList和Vector都是用數組實現的，所以，在添加和插入時，最好從表尾操作，而不要從中間或者表頭開始，以避免數組移動引起的開銷！
* （5）可以爲每個List生成ListIterator，支持雙向遍歷List，而且能夠在ListIterator位置插入和刪除元素。
* （6）堆棧類繼承Vector，它總是對列表的尾部數據進行操作，採用了先進後出的策略，自定義了插入、查看和彈出元素三個方法。 ArrayList 性能測試。
*
* @author sun
*/
public class TestList {

/** 
 * 初始化一個List 
 *  
 * @param list 
 */  
public static void init(List list) {  
    if (list != null) {  
        list.add("aaa");  
        list.add("ccc");  
        list.add("bbb");  
        list.add("eee");  
        list.add("ddd");  
    }  
}  

/** 
 * 輸出List的內容 
 *  
 * @param list 
 */  
public static void output(List list) {  
    if (list != null) {  
        // 根據列表下標遍歷，使用list.size()獲取列表中元素的個數  
        for (int i = 0; i < list.size(); i++) {  
            System.out.print(list.get(i) + "  ");  
        }  
        System.out.println();  
        // 或者用迭代器遍歷  
        Iterator it = list.iterator();  
        Object value = null;  
        while (it.hasNext()) {  
            value = it.next();  
            System.out.print(value + "  ");  
        }  
    }  
    System.out.println();  
}  

/** 
 * 使用ArrayList 
 */  
public static void testArrayList() {  
    List list = new ArrayList();  
    init(list);  
    System.out.println("使用ArrayList: ");  
    output(list);  
}  

/** 
 * 使用Vector 
 */  
public static void testVector() {  
    List list = new Vector();  
    init(list);  
    System.out.println("使用Vector: ");  
    output(list);  
}  

/** 
 * 使用LinkedList 
 */  
public static void testLinkedList() {  
    List list = new LinkedList();  
    init(list);  
    System.out.println("使用LinkedList: ");  
    output(list);  
}  

public static void main(String[] args) {  
    TestList.testArrayList();  
    // TestList.testVector();  
    // TestList.testLinkedList();  

    List list = new ArrayList();  
    init(list);  
    // 1:List支持元素重複  
    list.add("aaa");  
    list.add("bbb");  
    System.out.println("插入元素aaa, bbb後：");  
    output(list);  
    // 2:指定元素插入的位置  
    list.add(1, "fff");  
    System.out.println("在下標爲1處插入fff後：");  
    output(list);  
    List list2 = new ArrayList();  
    list2.add("ggg");  
    list2.add("hhh");  
    // 將另一列表中的元素插入到列表中  
    list.addAll(list2);  
    System.out.println("添加list2的元素後：");  
    output(list);  

    // 判斷列表是否包含某一元素  
    // 通過元素的equals方法，判斷元素是否相等  
    System.out.println("list包含aaa? " + list.contains("aaa"));  
    // 判斷列表中是否包含了另外一個列表中的所有元素。  
    System.out.println("list包含list2中的所有元素? " + list.containsAll(list2));  
    // 定位一個元素在列表中最先出現的位置  
    System.out.println("aaa在list中第一次出現的位置: " + list.indexOf("aaa"));  
    // 定位一個元素在列表中最後出現的位置  
    System.out.println("aaa在list中最後一次出現的位置: " + list.lastIndexOf("aaa"));  

    // 更新列表中某個位置的元素值  
    list.set(2, "xxx");  
    System.out.println("更新位置爲2的元素爲xxx後：");  
    output(list);  
    // 刪除列表中的某個元素，只刪除第一次出現的那個  
    list.remove("aaa");  
    System.out.println("刪除元素aaa後：");  
    output(list);  
    // 刪除列表中指定位置的元素  
    list.remove(1);  
    System.out.println("刪除下標爲1的元素後：");  
    output(list);  
    // 刪除列表中的其他元素，只保留另一個列表中包含的元素  
    list.retainAll(list2);  
    System.out.println("刪除除list2包含的以外的元素後：");  
    output(list);  
    // 刪除列表中在另一列表中也包含了的元素  
    list.removeAll(list2);  
    System.out.println("刪除list2包含的元素後：");  
    output(list);  
    // 清空列表  
    list.clear();  
    // 判斷列表中是否有數據  
    System.out.println("清空List後，list爲空麼?  " + list.isEmpty());  
    /* 
     * --------------------- 
     */  
    init(list);  
    // 用列表中的某些元素構造一個新的列表  
    list2 = list.subList(1, 3);  
    System.out.println("用list的第1個到第3個元素構造一個新的List:");  
    output(list2);  

    // 用List特有的遍歷器ListIterator遍歷列表  
    // 與普通的Iterator不用，它允許兩個方向遍歷列表  
    ListIterator listIt = list.listIterator();  
    System.out.println("正向遍歷列表");  
    while (listIt.hasNext()) {  
        System.out.print(listIt.next() + "  ");  
    }  
    System.out.println();  
    System.out.println("反向遍歷列表");  
    while (listIt.hasPrevious()) {  
        System.out.print(listIt.previous() + "  ");  
    }  
    System.out.println();  
    // 也可以使用ListIterator從List中間插入和刪除元素，  
    // 只能在遍歷器當前位置添加和刪除。  
    listIt.add("newadd");  
    System.out.println("用ListIterator往列表中添加元素newadd後: ");  
    output(list);  
    listIt.next();  
    listIt.remove();  
    System.out.println("用ListIterator刪除列表中元素後: ");  
    output(list);  

    // LinkedList自定義的方法  
    LinkedList linklist = new LinkedList();  
    init(linklist);  
    // 添加元素到列表頭  
    linklist.addFirst("fff");  
    System.out.println("把fff放到列表頭：");  
    output(linklist);  
    // 添加元素到列表尾  
    linklist.addLast("eee");  
    System.out.println("把eee放到列表尾：");  
    output(linklist);  
    // 獲取表頭元素  
    System.out.println("列表頭元素：" + linklist.getFirst());  
    // 獲取表尾元素  
    System.out.println("列表尾元素：" + linklist.getLast());  
    // 刪除列表頭的元素  
    linklist.removeFirst();  
    System.out.println("刪除列表頭元素：");  
    output(linklist);  
    // 刪除列表尾的元素  
    linklist.removeLast();  
    System.out.println("刪除列表尾元素：");  
    output(linklist);  

    // 堆棧Stack類，它繼承自Stack類  
    Stack myStack = new Stack();  
    // 插入元素，是插入到尾部  
    myStack.push("aaa");  
    myStack.push("bbb");  
    myStack.push("ccc");  
    myStack.push("ddd");  
    myStack.push("eee");  
    myStack.push("fff");  
    myStack.push("ggg");  
    System.out.println("堆棧中的元素是: ");  
    output(myStack);  
    /* 查看堆棧頂部的對象，但不從堆棧中移除它。 */  
    System.out.println("堆棧尾部元素: " + myStack.peek());  
    /* 移除堆棧頂部的對象，並返回該對象作爲此函數的值。 */  
    System.out.println("彈出堆棧尾部元素: " + myStack.pop());  
    System.out.println("再次彈出堆棧尾部元素: " + myStack.peek());  
    /* 把項壓入堆棧頂部。 */  
    myStack.push("sun");  
    System.out.println("再一次彈出堆棧尾部元素: " + myStack.peek());  
    if (myStack.empty()) {  
        System.out.println("myStack爲空！");  
    } else {  
        System.out.println("myStack不爲空！");  
    }  
    /* 對象到堆棧頂部的位置，以 1 爲基數；返回值 -1 表示此對象不在堆棧中。 */  
    System.out.println("返回對象在堆棧中的位置: " + myStack.search("fff"));  

}  

}
來源： http://blog.csdn.net/kevon_sun/article/details/7936329