Java 容器 & 泛型：2、ArrayList 、LinkedList和Vector比較

時間  2019-11-09
標籤 java 容器 arraylist linkedlist vector 比較 欄目 Java 简体版
原文   原文鏈接

Writer：BYSocket（泥沙磚瓦漿木匠）java

微博：BYSocketweb

豆瓣：BYSocket數組

繼續上一篇的容器文章認識容器，泥瓦匠慢慢帶大家走進List的容器解說。今天泥瓦匠想說說 ArrayList 、LinkedList和Vector比較。
安全

1、List回顧

序列（List），有序的Collection，正如它的名字同樣，是一個有序的元素列表。確切的講，列表一般容許知足 e1.equals(e2) 的元素對 e1 和 e2，而且若是列表自己容許 null 元素的話，一般它們容許多個 null 元素。實現List的有：ArrayList、LinkedList、Vector、Stack等。值得一提的是，Vector在JDK1.1的時候就有了，而List在JDK1.2的時候出現，待會咱們會聊到ArrayList和Vector的區別。數據結構

 

2、ArrayList vs. Vector

ArrayList是一個可調整大小的數組實現的序列。隨着元素增長，其大小會動態的增長。此類在Iterator或ListIterator迭代中，調用容器自身的remove和add方法進行修改，會拋出ConcurrentModificationException併發修改異常。下面演示下相關ArrayList例子。多線程

ArrayList基本方法代碼：併發

?異步

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
@SuppressWarnings({ "rawtypes", "unchecked" })
     public static void listMethods()
     {
         
         List a1 = new ArrayList< String >();
         
         a1.add("List01");
         a1.add("List03");
         a1.add("List04");
         System.out.print("原來集合：\n\t"+a1+"\n");
         
         a1.add(1,"List02");
         System.out.print("指定角標1插入：\n\t"+a1+"\n");
         
         a1.remove(2);
         System.out.print("指定角標2刪除：\n\t"+a1+"\n");
         
         System.out.print("指定角標2查詢：\n\t"+a1.get(2)+"\n");
         
         Iterator i1 = a1.iterator();
         System.out.println("用迭代器查詢所有元素：");
         while (i1.hasNext())
         {
             System.out.print(i1.next()+",");
         }
     }

能夠從控制檯能夠看出：socket

?性能

1
2
3
4
5
6
7
8
9
10
原來集合：
     [List01, List03, List04]
指定角標1插入：
     [List01, List02, List03, List04]
指定角標2刪除：
     [List01, List02, List04]
指定角標2查詢：
     List04
用迭代器查詢所有元素：
List01,List02,List04

在上面咱們能夠根據角標來增長(add)、刪除(remove)、獲取(get)列表裏面元素。ArrayList提供了Iterator迭代器來遍歷序列。值得注意的是，迭代器的就至關於一個指針指向角標，next()方法就至關於指針日後移一位。因此切記，用迭代器中一次循環用一次next()。

 

下面演示下在ConcurrentModificationException的出現，及處理方案。泥瓦匠用Iterator演示這個異常的出現：

@SuppressWarnings({ 「unchecked」, 「rawtypes」 })
    public static void iteratorTest()
    {
        List a1 = new ArrayList<String>();
        
        a1.add(「List01″);
        a1.add(「List02″);
        a1.add(「List04″);
        a1.add(「List05″);
        
        Iterator i1 = a1.iterator();
        while (i1.hasNext())
        {
            Object obj = i1.next();
            if (obj.equals(「List02″))
                a1.add(「List03″);
        }
        
        System.out.print(「集合：\n\t」+a1+」\n」);
    }
運行，咱們能夠在控制檯看到：
image

怎麼解決的，先看清楚這個問題。問題描述很清楚，在建立迭代器以後，除非經過迭代器自身的 remove 或 add 方法從結構上對列表進行修改，不然在任什麼時候間以任何方式對列表進行修改，迭代器都會拋出ConcurrentModificationException。

所以咱們應該這樣修改代碼，用ListIterator迭代器提供方法，：

?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
@SuppressWarnings({ "unchecked", "rawtypes" })
     public static void listIterator()
     {
         
         List a1 = new ArrayList< String >();
         
         a1.add("List01");
         a1.add("List");
         a1.add("List03");
         a1.add("List04");
         
         ListIterator l1 = a1.listIterator();
         while (l1.hasNext())
         {
             Object obj = l1.next();
             if (obj.equals("List"))
             {
                 l1.remove();
                 l1.add("List02");
             }
         }
         System.out.print("集合：\n\t"+a1+"\n");
     }

運行下，咱們能夠看到：

?

1
2
集合：
     [List01, List02, List03, List04]

這樣，咱們成功解決了這個併發修改異常。把其中‘List’元素刪除，新增了一個‘List02’的元素。

 

Vector很是相似ArrayList。早在JDK1.1的時候就出現了，之前沒有所謂的List接口，如今此類被改進爲實現List接口。但與新的Collection不一樣的是，Vector是同步的。泥瓦匠想說的是Vector，在像查詢的性能上會比ArrayList開銷大。下面演示下Vector的基本例子：

?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@SuppressWarnings({ "unchecked", "rawtypes" })
     public static void vectorMethods()
     {
         Vector v1 = new Vector< String >();
         
         v1.add("Vector001");
         v1.add("Vector002");
         v1.add("Vector003");
         v1.add("Vector004");
         v1.add("Vector005");
         
         Enumeration e1 =v1.elements();
         while (e1.hasMoreElements())
         {
             Object object = e1.nextElement();
             System.out.println(object);
         }
     }

從方法上看幾乎沒差異，一樣注意的是：此接口的功能與 Iterator 接口的功能是重複的。此外，Iterator 接口添加了一個可選的移除操做，並使用較短的方法名。新的實現應該優先考慮使用 Iterator 接口而不是 Enumeration 接口。

 

3、LinkedList及其與ArrayList性能比

LinkedList與ArrayList同樣實現List接口，LinkedList是List接口鏈表的實現。基於鏈表實現的方式使得LinkedList在插入和刪除時更優於ArrayList，而隨機訪問則比ArrayList遜色些。LinkedList實現全部可選的列表操做，並容許全部的元素包括null。除了實現 List 接口外，LinkedList 類還爲在列表的開頭及結尾 get、remove 和 insert 元素提供了統一的命名方法。這些操做容許將連接列表用做堆棧、隊列或雙端隊列。

LinkedList和ArrayList的方法時間複雜度總結以下圖所示。
image

表中，添加add()指添加元素的方法，remove()是指除去（int index）角標。ArrayList具備O（N）的任意指數時間複雜度的添加/刪除，但O（1）的操做列表的末尾。鏈表的O（n）的任意指數時間複雜度的添加/刪除，但O（1）操做端/列表的開始。

 

泥瓦匠用代碼驗證下這個結論：

?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
public static void testPerBtwnArlAndLkl()
     {
         ArrayList< Integer > arrayList   = new ArrayList< Integer >();
         LinkedList< Integer > linkedList = new LinkedList< Integer >();
                 
         // ArrayList add
         long startTime  = System.nanoTime();
         long endTime;
         long duration;
          
         for (int i = 0; i <  100000 ; i++) {
             arrayList.add(i);
         }
         endTime =  System .nanoTime();
         duration =  endTime - startTime;
         System.out.println("ArrayList add:  " + duration);
          
         // LinkedList add
         startTime =  System .nanoTime();
          
         for (int  i =  0 ; i < 100000; i++) {
             linkedList.add(i);
         }
         endTime =  System .nanoTime();
         duration =  endTime - startTime;
         System.out.println("LinkedList add: " + duration);
          
         // ArrayList get
         startTime =  System .nanoTime();
          
         for (int  i =  0 ; i < 10000; i++) {
             arrayList.get(i);
         }
         endTime =  System .nanoTime();
         duration =  endTime - startTime;
         System.out.println("ArrayList get:  " + duration);
          
         // LinkedList get
         startTime =  System .nanoTime();
          
         for (int  i =  0 ; i < 10000; i++) {
             linkedList.get(i);
         }
         endTime =  System .nanoTime();
         duration =  endTime - startTime;
         System.out.println("LinkedList get: " + duration);
          
         // ArrayList remove
         startTime =  System .nanoTime();
          
         for (int  i =  9999 ; i >=0; i--) {
             arrayList.remove(i);
         }
         endTime = System.nanoTime();
         duration = endTime - startTime;
         System.out.println("ArrayList remove:  " + duration);
          
         // LinkedList remove
         startTime = System.nanoTime();
          
         for (int i = 9999; i >=0; i--) {
             linkedList.remove(i);
         }
         endTime = System.nanoTime();
         duration = endTime - startTime;
         System.out.println("LinkedList remove: " + duration);
     }

控制檯輸出以下：

?

1
2
3
4
5
6
ArrayList add:  16904776
LinkedList add: 12015418
ArrayList get:  1304593
LinkedList get: 108950741
ArrayList remove:  787388127
LinkedList remove: 128145950

對比下的話，其性能差距很明顯。LinkedList在添加和刪除中性能快，但在獲取中性能差。從複雜度和測試結果，咱們應該懂得平時在添加或者刪除操做頻繁的地方，選擇LinkedList時考慮：

一、沒有大量的元素的隨機訪問

二、添加/刪除操做

 

天然我下面用LinedList實現一個數據結構–棧。泥瓦匠留給你們LinkedList的一些方法本身消化下。

?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
package com.sedion.bysocket.collection;
import java.util.LinkedList;
 
/**
  * 用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();
     }
     
     public static void main(String[] args)
     {
         Stack stack=new Stack< String >();
         stack.push("a");
         stack.push("b");
         stack.push("c");
         System.out.println(stack.toString());
         Object obj=stack.peek();
         System.out.println(obj+"--"+stack.toString());
         obj=stack.pop();
         System.out.println(obj+"--"+stack.toString());
         System.out.println(stack.empty());
     }
}

4、總結

泥瓦匠總結以下：

Vector和ArrayList

一、vector是線程同步的，因此它也是線程安全的，而arraylist是線程異步的，是不安全的。

二、記住併發修改異常 java.util.ConcurrentModificationException ，優先考慮ArrayList，除非你在使用多線程所需。

Aarraylist和Linkedlist一、對於隨機訪問get和set，ArrayList以爲優於LinkedList，LinkedList要移動指針。二、於新增和刪除操做add和remove，LinedList比較佔優點，ArrayList要移動數據。三、單條數據插入或刪除，ArrayList的速度反而優於LinkedList.如果批量隨機的插入刪除數據，LinkedList的速度大大優於ArrayList. 由於ArrayList每插入一條數據，要移動插入點及以後的全部數據。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程