一、先來看看ArrayList與LinkedList 在JDK中所在的位置

從圖中可以看出,ArrayList與LinkedList都是List介面的實現類,因此都實現了List的所有未實現的方法,只是實現的方式有所不同,(程式設計思想: 從中可以看出面向介面的好處, 對於不同的需求就有不同的實現!),而List介面繼承了Collection介面,Collection介面又繼承了Iterable介面,因此可以看出List同時擁有了Collection與Iterable介面的特性.

二、認識和理解ArrayList

ArrayList實現了List介面,它是以陣列的方式來實現的,陣列的特性是可以使用索引的方式來快速定位物件的位置,因此對於快速的隨機取得物件的需求,使用ArrayList實現執行效率上會比較好. 

ArrayListDemo:

1. public class ArrayListDemo {  
2.     public static void main(String[] args) {  
3.         List<String> userlist = new ArrayList<String>();  
4.         userlist.add("yulon");  
5.         userlist.add("xiaoyun");  
6.         userlist.add("羽龍共舞");  
7.         System.out.println("使用普通for迴圈:"
   );  
8.         for(int i=0; i<userlist.size(); i++){  
9.             System.out.print(userlist.get(i)+" ");  
10.         }  
11.         System.out.println();  
12.         System.out.println();  
13.         System.out.println("使用Iterator迭代器:");  
14.         Iterator it = userlist.iterator();  
15.         while(it.hasNext()){  
16.             System.out.print(it.next()+" ");  
17.         }  
18.         System.out.println();  
19.         System.out.println();  
20.         System.out.println("使用增強for迴圈:");  
21.         for(String s : userlist){  
22.             System.out.print(s+" ");  
23.         }  
24.     }  
25. }  

 這裡列舉出了迴圈List列表的三種方式: 使用普通for迴圈,用get方法獲取; 使用Iterator迭代器,使用next方法遍歷;使用增強for迴圈,直接輸出!  由此可見第三種方法是最方便，最簡潔的!

三、認識和理解LinkedList

LinkedList是採用連結串列的方式來實現List介面的,它本身有自己特定的方法，如: addFirst(),addLast(),getFirst(),removeFirst()等. 由於是採用連結串列實現的,因此在進行insert和remove動作時在效率上要比ArrayList要好得多!適合用來實現Stack(堆疊)與Queue(佇列),前者先進後出，後者是先進先出.

 1、堆疊

1. public class StringStack {  
2.     private LinkedList<String> linkedList   
3.     = new LinkedList<String>();  
4.     /** 
5.      * 將元素加入LinkedList容器 
6.      * (即插入到連結串列的第一個位置) 
7.      */  
8.     public void push(String name){  
9.         linkedList.addFirst(name);  
10.     }  
11.     /** 
12.      * 取出堆疊中最上面的元素 
13.      * (即取出連結串列linkedList的第一個元素) 
14.      * @return 
15.      */  
16.     public String getTop(){  
17.         return linkedList.getFirst();  
18.     }  
19.     /** 
20.      * 取出並刪除最上面的元素 
21.      * (即移出linkedList的第一個元素) 
22.      * @return 
23.      */  
24.     public String pop(){  
25.         return linkedList.removeFirst();  
26.     }  
27.     /** 
28.      * 獲取元素個數 
29.      * @return 
30.      */  
31.     public int size(){  
32.         return linkedList.size();  
33.     }  
34.     /** 
35.      * 判斷堆疊是否為空 
36.      * (即判斷 linkedList是否為空) 
37.      * @return 
38.      */  
39.     public boolean isEmpty(){  
40.         return linkedList.isEmpty();  
41.     }  
42.     //測試  
43.     public static void main(String[] args) {  
44.         StringStack stack = new StringStack();  
45.         stack.push("yulon");  
46.         stack.push("xiaoyun");  
47.         stack.push("羽龍共舞");  
48.         System.out.print("第一個元素是:\t");  
49.         System.out.println(stack.getTop());  
50.         System.out.println();  
51.         System.out.println("全部元素:");  
52.         while(!stack.isEmpty()){  
53.             System.out.println("\t"+stack.pop());  
54.         }  
55.     }  
56. }  

輸出結果是:

1. 第一個元素是: 羽龍共舞  
2. 全部元素:  
3.     羽龍共舞  
4.     xiaoyun  
5.     yulon  

知識提示: LinkedList的特有方法(本身定義的方法)如:addFirst()、addLast()、getFirst()、getLast()、removeFirst()、removeLast()等

  2、實現佇列類似,在此不再舉例

  3、如果要使用佇列的功能,由於LinkedList也實現了java.util.Queue介面,所以可以直接使用LinkedList的例項來實現.

1. public class QueueDemo {  
2.     public static void main(String[] args) {  
3.         //父類引用queue指向子類物件  
4.         Queue<String> queue = new LinkedList<String>();  
5.         //offer()方法是往佇列加入元素  
6.         queue.offer("xiaoyun");  
7.         queue.offer("yulon");  
8.         queue.offer("羽龍共舞");  
9.         String element = null;  
10.         while((element=queue.poll())!=null){  
11.             System.out.println(element+"\t");  
12.         }  
13.     }  
14. }  

輸出順序是:

1. xiaoyun   
2. yulon     
3. 羽龍共舞      

四、在刪除可插入物件的動作時，為什麼ArrayList的效率會比較低呢?

解析: 因為ArrayList是使用陣列實現的,若要從陣列中刪除或插入某一個物件，需要移動後段的陣列元素，從而會重新調整索引順序,調整索引順序會消耗一定的時間，所以速度上就會比LinkedList要慢許多. 相反,LinkedList是使用連結串列實現的,若要從連結串列中刪除或插入某一個物件,只需要改變前後物件的引用即可!