ArrayList vs. LinkedList vs. Vector

1. List概述

List,就如图名字所示一样,是元素的有序列表。当我们讨论List时，将其与Set作对比是一个很好的办法,Set集合中的元素是无序且唯一的。
下图是Collection的类继承图,从图中你可以对本文所讨论的知识有大致的了解.

图1

2. ArrayList、LinkedList与Vector的对比
从图中可以看出,这三者都实现了 List  接口.所有使用方式也很相似,主要区别在于因为实现方式的不同,所以对不同的操作具有不同的效率。
ArrayList  是一个可改变大小的数组.当更多的元素加入到ArrayList中时,其大小将会动态地增长.内部的元素可以直接通过get与set方法进行访问,因为ArrayList本质上就是一个数组.
LinkedList 是一个双链表,在添加和删除元素时具有比ArrayList更好的性能.但在get与set方面弱于ArrayList.
当然,这些对比都是指数据量很大或者操作很频繁的情况下的对比,如果数据和运算量很小,那么对比将失去意义.
Vector 和ArrayList类似,但属于强同步类 。如果你的程序 本身是线程安全的 (thread-safe,没有在多个线程之间共享同一个集合/对象),那么使用ArrayList是更好的选择。
Vector和ArrayList在更多元素添加进来时会请求更大的空间。Vector每次请求其大小的双倍空间，而ArrayList每次对size增长50%.
而  LinkedList  还实现了  Queue  接口,该接口比List提供了更多的方法,包括 offer(),peek(),poll()等.
注意: 默认情况下ArrayList的初始容量非常小,所以如果可以预估数据量的话,分配一个较大的初始值属于最佳实践,这样可以减少调整大小的开销。
3. ArrayList示例

[java]  view plain  copy

 

1. public static void testArrayList() {  
2.     ArrayList<Integer> al = new ArrayList<Integer>();  
3.     al.add(3);  
4.     al.add(2);          
5.     al.add(1);  
6.     al.add(4);  
7.     al.add(5);  
8.     al.add(6);  
9.     al.add(6);  
10.   
11.   
12.     Iterator<Integer> iter1 = al.iterator();  
13.     while(iter1.hasNext()){  
14.         System.out.println(iter1.next());  
15.     }  
16. }  

4. LinkedList示例

[java]  view plain  copy

 

1. public static void testLinkedList() {  
2.     LinkedList<Integer> ll = new LinkedList<Integer>();  
3.     ll.add(3);  
4.     ll.add(2);          
5.     ll.add(1);  
6.     ll.add(4);  
7.     ll.add(5);  
8.     ll.add(6);  
9.     ll.add(6);  
10.   
11.   
12.     Iterator<Integer> iter2 = ll.iterator();  
13.     while(iter2.hasNext()){  
14.         System.out.println(iter2.next());  
15.     }  
16. }  

如上面的例子所示,其使用方式是相似的,实际的区别在于底层的实现方式以及操作的复杂性不同.
5. Vector
Vector和ArrayList几乎是完全相同的,唯一的区别在于Vector是同步类(synchronized).因此,开销就比ArrayList要大.正常情况下,大多数的Java程序员使用ArrayList而不是Vector,因为同步完全可以由程序员自己来控制。
6. ArrayList与LinkedList性能对比
时间复杂度对比如下:

	ArrayList	LinkedList
get()	O(1)	O(n)
add()	O(1)	O(1) amortized
remove()	O(n)	O(n)

*  表中的 add() 代表 add(E e),而 remove()代表 remove(int index)'

• ArrayList 对于随机位置的add/remove，时间复杂度为 O(n),但是对于列表末尾的添加/删除操作,时间复杂度是 O(1). 
• LinkedList对于随机位置的add/remove，时间复杂度为 O(n),但是对于列表 末尾/开头 的添加/删除操作,时间复杂度是 O(1).

我使用下面的代码来测试他们的性能:

[java]  view plain  copy

 

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

输出结果如下:

[plain]  view plain  copy

 

1. Test times = 10000  
2. -------------------------  
3. 1469985 <--ArrayList add  
4. 3530491 <--LinkedList add  
5. -------------------------  
6. 593678 <--ArrayList get  
7. 86914251 <--LinkedList get  
8. -------------------------  
9. 625651 <--ArrayList remove  
10. 2164320 <--LinkedList remove  

[java]  view plain  copy

 

1. Test times = 100000  
2. -------------------------  
3. 11480805 <--ArrayList add  
4. 26384338 <--LinkedList add  
5. -------------------------  
6. 714072 <--ArrayList get  
7. 10040809061 <--LinkedList get  
8. -------------------------  
9. 1203935 <--ArrayList remove  
10. 1595905 <--LinkedList remove  

[plain]  view plain  copy

 

1. 在 1000*1000次的运行中,很长时间过后, LinkedList的get日志还没有打印出来，大概是15分钟左右,结果还是没有出来.  

[java]  view plain  copy

 

1. Test times = 1000000  
2. -------------------------  
3. 132632998 <--ArrayList add  
4. 322885939 <--LinkedList add  
5. -------------------------  
6. 3690752 <--ArrayList get  
7. 1520315361147 <--LinkedList get  
8. -------------------------  
9. 8750043 <--ArrayList remove  
10. 13872885 <--LinkedList remove  

他们性能的差异相当明显, LinkedList在 add和remove 上更快,而在get上更慢(原文是这样的).

译者注: 译者的编译和执行环境是 MyEclipse的JDK6,不论怎么看,都是 ArrayList更胜一筹,所以,该怎么选择,请根据自己的实际情况来决定，最好自己做测试，因为数据类型不同,JDK版本不同,优化不同，就可能有不同的结果。

根据时间复杂度表格,以及测试结果,我们可以判断何时该用ArrayList,何时该用LinkedList.

简单来说,LinkedList更适用于:

• 没有大规模的随机读取
• 大量的增加/删除操作
• 
  
• 
  
• ArraylistAPI

三个构造函数

1.public ArrayList(int initialCapacity);

 构造一个具有指定初始容量的空列表

2.pubilc ArrayList();

 构造一个初始容量为10的空列表

3.public ArrayList(Collection<> c)

构造一个包含指定collection的元素的列表。

若collection为null，会抛出NullPointerException

其他常用方法

4.trimToSize

    public void trimToSize();

   将此ArrayList的容量调整为列表的当前大小。应用程序可以使用此操作来最小化ArrayList 实例的存储量。 

5.size

  public int size();

 返回此列表中的元素数。

6.isEmpty

  public boolean isEmpty();

  如果此列表中没有元素，则返回 true

7.contains

 public boolean contains(Object o);

 如果此列表中包含指定的元素，则返回 true

8.indexOf

 public int indexOf(Object o)

 返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。

9.lastIndexOf

 public int lastIndexOf(Object o)

 返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。

10.toArray

 public Object[] toArray();

 按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组。

 由于此列表不维护对返回数组的任何引用，，因而它将是“安全的”。（换句话说，此方法必须分配一个新的数组）。因此，调用者可以自由地修改返回的数组。

 此方法担当基于数组的 API 和基于 collection 的 API 之间的桥梁。

11.get

  public E get(int index);

  返回此列表中指定位置上的元素

12.set

 public E set(int index, E element);

 用指定的元素替代此列表中指定位置上的元素。返回值为以前位于该指定位置上的元素

13.add

 public boolean add(E element);

 将指定的元素添加到此列表的尾部。添加成功返回true

14.add

 public void add(int index, E element)

 将指定的元素插入此列表中的指定位置。向右移动当前位于该位置的元素（如果有）以及所有后续元素（将其索引加 1）。

15.remove

 public E remove(int index)

 移除此列表中指定位置的元素，返回从列表中移除的元素

16.remove

 public boolean remove(Object o)

 移除此列表中首次出现的指定元素（如果存在）。如果列表不包含此元素，则列表不做改动。

17.clear

 public void clear()

 移除此列表中的所有元素。此调用返回后，列表将为空

18.addAll

  public boolean addAll(Collection c)

  按照指定 collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素添加到此列表的尾部

19.addAll

 public boolean addAll(int index, Collection c)

 从指定的位置开始，将指定 collection 中的所有元素插入到此列表中。

20.removeRange

 protected void removeRange(int fromIndex, int endIndex);

 移除列表中索引在 fromIndex（包括）和toIndex（不包括）之间的所有元素。向左移动所有后续元素（减小其索引）。此调用将列表缩短了 (toIndex - fromIndex) 个元素。（如果toIndex==fromIndex，则此操作无效。）

LinkedList  API

LinkedList类是双向列表,列表中的每个节点都包含了对前一个和后一个元素的引用.
LinkedList的构造函数如下
1. public LinkedList():  ——生成空的链表
2. public LinkedList(Collection col):  复制构造函数
1、获取链表的第一个和最后一个元素

[java]  view plain copy

1. import java.util.LinkedList;  
2.   
3. public class LinkedListTest{  
4.   public static void main(String[] args) {  
5.     LinkedList<String> lList = new LinkedList<String>();  
6.     lList.add("1");  
7.     lList.add("2");  
8.     lList.add("3");  
9.     lList.add("4");  
10.     lList.add("5");  
11.   
12.   
13.     System.out.println("链表的第一个元素是 : " + lList.getFirst());  
14.     System.out.println("链表最后一个元素是 : " + lList.getLast());  
15.   }  
16. }  

2、获取链表元素  

[java]  view plain copy

1. for (String str: lList) {  
2.       System.out.println(str);  
3.     }  

3、从链表生成子表

[java]  view plain copy

1. List subl = lList.subList(1, 4);  
2.     System.out.println(subl);  
3.     lst.remove(2);  
4.     System.out.println(lst);  
5.     System.out.println(lList);  

4、添加元素：添加单个元素
 如果不指定索引的话，元素将被添加到链表的最后.
public boolean add(Object element)
public boolean add(int index, Object element)
也可以把链表当初栈或者队列来处理:
public boolean addFirst(Object element)
public boolean addLast(Object element)
addLast()方法和不带索引的add()方法实现的效果一样.

[java]  view plain copy

1. import java.util.LinkedList;  
2.   
3. public class LinkedListTest{  
4.   public static void main(String[] a) {  
5.     LinkedList list = new LinkedList();  
6.     list.add("A");  
7.     list.add("B");  
8.     list.add("C");  
9.     list.add("D");  
10.     list.addFirst("X");  
11.     list.addLast("Z");  
12.     System.out.println(list);  
13.   }  
14. }  

5、删除元素

[java]  view plain copy

1. public Object removeFirst()  
2. public Object removeLast()  
3. import java.util.LinkedList;  
4.   
5.   
6. public class MainClass {  
7.   public static void main(String[] a) {  
8.   
9.   
10.     LinkedList list = new LinkedList();  
11.     list.add("A");  
12.     list.add("B");  
13.     list.add("C");  
14.     list.add("D");  
15.     list.removeFirst();  
16.     list.removeLast();  
17.     System.out.println(list);  
18.   }  
19. }  

6、使用链表实现栈效果

[java]  view plain copy

1. import java.util.LinkedList;  
2. public class MainClass {  
3.   public static void main(String[] args) {  
4.     StackL stack = new StackL();  
5.     for (int i = 0; i < 10; i++)  
6.       stack.push(i);  
7.     System.out.println(stack.top());  
8.     System.out.println(stack.top());  
9.     System.out.println(stack.pop());  
10.     System.out.println(stack.pop());  
11.     System.out.println(stack.pop());  
12.   }  
13. }  
14. class StackL {  
15.   private LinkedList list = new LinkedList();  
16.   public void push(Object v) {  
17.     list.addFirst(v);  
18.   }  
19.   public Object top() {  
20.     return list.getFirst();  
21.   }  
22.   public Object pop() {  
23.     return list.removeFirst();  
24.   }  
25. }  

7、使用链表来实现队列效果

[java]  view plain copy

1. import java.util.LinkedList;  
2. public class MainClass {  
3.   public static void main(String[] args) {  
4.     Queue queue = new Queue();  
5.     for (int i = 0; i < 10; i++)  
6.       queue.put(Integer.toString(i));  
7.     while (!queue.isEmpty())  
8.       System.out.println(queue.get());  
9.   }  
10. }  
11. class Queue {  
12.   private LinkedList list = new LinkedList();  
13.   public void put(Object v) {  
14.     list.addFirst(v);  
15.   }  
16.   public Object get() {  
17.     return list.removeLast();  
18.   }  
19.   public boolean isEmpty() {  
20.     return list.isEmpty();  
21.   }  
22. }  

8、将LinkedList转换成ArrayList

[java]  view plain copy

1. ArrayList<String> arrayList = new ArrayList<String>(linkedList);  
2.     for (String s : arrayList) {  
3.       System.out.println("s = " + s);  
4.     }  

9、删掉所有元素：清空LinkedList
    lList.clear();
10、删除列表的首位元素

[java]  view plain copy

1. import java.util.LinkedList;  
2. public class Main {  
3.   public static void main(String[] args) {  
4.     LinkedList<String> lList = new LinkedList<String>();  
5.     lList.add("1");  
6.     lList.add("2");  
7.     lList.add("3");  
8.     lList.add("4");  
9.     lList.add("5");  
10.     System.out.println(lList);  
11.         //元素在删除的时候，仍然可以获取到元素  
12.     Object object = lList.removeFirst();  
13.     System.out.println(object + " has been removed");  
14.     System.out.println(lList);  
15.     object = lList.removeLast();  
16.     System.out.println(object + " has been removed");  
17.     System.out.println(lList);  
18.   }  
19. }  

11、根据范围删除列表元素

[java]  view plain copy

1. import java.util.LinkedList;  
2. public class Main {  
3.   public static void main(String[] args) {  
4.     LinkedList<String> lList = new LinkedList<String>();  
5.     lList.add("1");  
6.     lList.add("2");  
7.     lList.add("3");  
8.     lList.add("4");  
9.     lList.add("5");  
10.     System.out.println(lList);  
11.     lList.subList(2, 5).clear();  
12.     System.out.println(lList);  
13.   }  
14. }  

12、删除链表的特定元素

[java]  view plain copy

1. import java.util.LinkedList;  
2. public class Main {  
3.   public static void main(String[] args) {  
4.     LinkedList<String> lList = new LinkedList<String>();  
5.     lList.add("1");  
6.     lList.add("2");  
7.     lList.add("3");  
8.     lList.add("4");  
9.     lList.add("5");  
10.     System.out.println(lList);  
11.     System.out.println(lList.remove("2"));//删除元素值=2的元素  
12.     System.out.println(lList);  
13.     Object obj = lList.remove(2);  //删除第二个元素  
14.     System.out.println(obj + " 已经从链表删除");  
15.     System.out.println(lList);  
16.   }  
17. }  

13、将LinkedList转换为数组，数组长度为0

[java]  view plain copy

1. import java.util.LinkedList;  
2. import java.util.List;  
3. public class Main {  
4.   public static void main(String[] args) {  
5.     List<String> theList = new LinkedList<String>();  
6.     theList.add("A");  
7.     theList.add("B");  
8.     theList.add("C");  
9.     theList.add("D");  
10.     String[] my = theList.toArray(new String[0]);  
11.     for (int i = 0; i < my.length; i++) {  
12.       System.out.println(my[i]);  
13.     }  
14.   }  
15. }  

14、将LinkedList转换为数组，数组长度为链表长度

[java]  view plain copy

1. import java.util.LinkedList;  
2. import java.util.List;  
3. public class Main {  
4.   public static void main(String[] args) {  
5.     List<String> theList = new LinkedList<String>();  
6.     theList.add("A");  
7.     theList.add("B");  
8.     theList.add("C");  
9.     theList.add("D");  
10.     String[] my = theList.toArray(new String[theList.size()]);  
11.     for (int i = 0; i < my.length; i++) {  
12.       System.out.println(my[i]);  
13.     }  
14.   }  
15. }  

15、将LinkedList转换成ArrayList

[java]  view plain copy

1. import java.util.ArrayList;  
2. import java.util.LinkedList;  
3. import java.util.List;  
4. public class Main {  
5.   public static void main(String[] args) {  
6.     LinkedList<String> myQueue = new LinkedList<String>();  
7.     myQueue.add("A");  
8.     myQueue.add("B");  
9.     myQueue.add("C");  
10.     myQueue.add("D");  
11.     List<String> myList = new ArrayList<String>(myQueue);  
12.     for (Object theFruit : myList)  
13.       System.out.println(theFruit);  
14.   }  
15. }  

16、实现栈

[java]  view plain copy

1. import java.util.Collections;  
2. import java.util.LinkedList;  
3. public class Main {  
4.   public static void main(String[] argv) throws Exception {  
5.     LinkedList stack = new LinkedList();  
6.     Object object = "";  
7.     stack.addFirst(object);  
8.     Object o = stack.getFirst();  
9.     stack = (LinkedList) Collections.synchronizedList(stack);  
10.   }  
11. }  

17、实现队列

[java]  view plain copy

1. import java.util.LinkedList;  
2. public class Main {  
3.   public static void main(String[] argv) throws Exception {  
4.     LinkedList queue = new LinkedList();  
5.     Object object = "";  
6.     // Add to end of queue  
7.     queue.add(object);  
8.     // Get head of queue  
9.     Object o = queue.removeFirst();  
10.   }  
11. }  

18 、同步方法

[java]  view plain copy

1. import java.util.Collections;  
2. import java.util.LinkedList;  
3. public class Main {  
4.   public static void main(String[] argv) throws Exception {  
5.     LinkedList queue = new LinkedList();  
6.     Object object = "";  
7.     queue.add(object);  
8.     Object o = queue.removeFirst();  
9.     queue = (LinkedList) Collections.synchronizedList(queue);  
10.   }  
11. }  

19、查找元素位置

[java]  view plain copy

1. import java.util.LinkedList;  
2.   
3. public class Main {  
4.   public static void main(String[] args) {  
5.     LinkedList<String> lList = new LinkedList<String>();  
6.     lList.add("1");  
7.     lList.add("2");  
8.     lList.add("3");  
9.     lList.add("4");  
10.     lList.add("5");  
11.     lList.add("2");  
12.     System.out.println(lList.indexOf("2"));  
13.     System.out.println(lList.lastIndexOf("2"));  
14.   }  
15. }  

20、替换元素

[java]  view plain copy

1. import java.util.LinkedList;  
2.   
3. public class Main {  
4.   public static void main(String[] args) {  
5.     LinkedList<String> lList = new LinkedList<String>();  
6.     lList.add("1");  
7.     lList.add("2");  
8.     lList.add("3");  
9.     lList.add("4");  
10.     lList.add("5");  
11.     System.out.println(lList);  
12.     lList.set(3, "Replaced");//使用set方法替换元素，方法的第一个参数是元素索引，后一个是替换值  
13.     System.out.println(lList);  
14.   }  
15. }  

21、链表添加对象

[java]  view plain copy

1. import java.util.LinkedList;  
2. class Address {  
3.   private String name;  
4.   private String street;  
5.   private String city;  
6.   private String state;  
7.   private String code;  
8.   Address(String n, String s, String c, String st, String cd) {  
9.     name = n;  
10.     street = s;  
11.     city = c;  
12.     state = st;  
13.     code = cd;  
14.   }  
15.   public String toString() {  
16.     return name + " " + street + " " + city + " " + state + " " + code;  
17.   }  
18. }  
19.   
20.   
21. class MailList {  
22.   public static void main(String args[]) {  
23.     LinkedList<Address> ml = new LinkedList<Address>();  
24.     ml.add(new Address("A", "11 Ave", "U", "IL", "11111"));  
25.     ml.add(new Address("R", "11 Lane", "M", "IL", "22222"));  
26.     ml.add(new Address("T", "8 St", "C", "IL", "33333"));  
27.     for (Address element : ml)  
28.       System.out.println(element + "\n");  
29.   }  
30. }  

22、确认链表是否存在特定元素

[java]  view plain copy

1. import java.util.LinkedList;  
2.   
3.   
4. public class Main {  
5.   public static void main(String[] args) {  
6.     LinkedList<String> lList = new LinkedList<String>();  
7.     lList.add("1");  
8.     lList.add("2");  
9.     lList.add("3");  
10.     lList.add("4");  
11.     lList.add("5");  
12.     if (lList.contains("4")) {  
13.       System.out.println("LinkedList contains 4");  
14.     } else {  
15.       System.out.println("LinkedList does not contain 4");  
16.     }  
17.   }  
18. }  

23、根据链表元素生成对象数组

[java]  view plain copy

1. Object[] objArray = lList.toArray();  
2. for (Object obj: objArray) {  
3.    System.out.println(obj);  
4. }