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

Writer：BYSocket（泥沙砖瓦浆木匠）

微博：BYSocket

豆瓣：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()+",");          }      }

能够从控制台能够看出：

?

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”);
    }
运行，咱们能够在控制台看到：

怎么解决的，先看清楚这个问题。问题描述很清楚，在建立迭代器以后，除非经过迭代器自身的 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的方法时间复杂度总结以下图所示。

表中，添加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每插入一条数据，要移动插入点及以后的全部数据。