以下文章是本人在網上找了些資料， 加以修改，優化了一下，並且查詢jdk增加了一些方法和註釋，貼出來給網友們看看。

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"));

	}
}