java笔记三：List接口

　　List承诺可以将元素维护在特定的序列中。List接口在Collection的基础上添加了大量的方法，使得可以在List的中间插入和删除元素。List与 set 不同，列表通常允许重复的元素。并且存放的顺序与插入的顺序一致。

　　List接口的常用方法有：

　　**[add](http://www.cnblogs.com/java/util/List.html#add(E))**([E](http://www.cnblogs.com/java/util/List.html "List 中的类型参数") o)   :将指定对象加入到列表中。

　　**[add](http://www.cnblogs.com/java/util/List.html#add(int,
E))**(int index, [E](http://www.cnblogs.com/java/util/List.html "List
中的类型参数") element)  ：将对象加入到指定位置处。

　　**[addAll](http://www.cnblogs.com/java/util/List.html#addAll(java.util.Collection))**([Collection](http://www.cnblogs.com/java/util/Collection.html
"java.util 中的接口")<? extends
[E](http://www.cnblogs.com/java/util/List.html "List 中的类型参数")> c)  ：追加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序（可选操作）。

　　**[addAll](http://www.cnblogs.com/java/util/List.html#addAll(int,
java.util.Collection))**(int index,
[Collection](http://www.cnblogs.com/java/util/Collection.html "java.util
中的接口")<? extends [E](http://www.cnblogs.com/java/util/List.html
"List 中的类型参数")> c) ：将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。

　　**[remove](http://www.cnblogs.com/java/util/List.html#remove(int))**(int index) ：移除某个位置上的元素。

　　**[remove](http://www.cnblogs.com/java/util/List.html#remove(java.lang.Object))**([Object](http://www.cnblogs.com/java/lang/Object.html
"java.lang 中的类") o) ： 移除列表中出现的首个指定元素。

　　**[set](http://www.cnblogs.com/java/util/List.html#set(int,
E))**(int index, [E](http://www.cnblogs.com/java/util/List.html "List
中的类型参数") element) ：用指定元素替换列表中指定位置的元素。

　　**[size](http://www.cnblogs.com/java/util/List.html#size())**() ：返回列表大小。
…….

　　常用的有两种List类型：ArrayList和LinkedList。

一、ArrayList

　　ArrayList擅长于随即访问元素，因为它像数组一样提供了下标，可以根据下标直接访问,所以可以将ArrayList看作可扩充自身尺寸的数组。但是在ArrayList的中间插入和移除元素时较慢。

 1 package com.list;
 2
 3 import java.util.ArrayList;
 4 import java.util.Iterator;
 5 import java.util.List;
 6
 7 public class ArrayListTest {
 8     public static void main(String[] args) {
 9         List list = new ArrayList();
10         //添加元素
11         list.add(“aaa”);
12         list.add(“bbb”);
13         list.add(“aaa”);
14         list.add(“ddd”);
15         list.add(“ccc”);
16         list.add(null);
17         //遍历
18         for (String string : list) {
19             System.out.println(string);
20         }
21         System.out.println(“—————“);
22         //修改
23         list.set(1, “bbb2”);
24         //删除
25         list.remove(“ccc”);
26         //迭代器遍历
27         Iterator iterator = list.iterator();
28         while(iterator.hasNext()){
29             System.out.println(iterator.next());
30         }
31         System.out.println(“————–”);
32         list.clear(); //清空列表
33         System.out.println(“清空后list的大小”+list.size());//打印大小
34         List list2 = new ArrayList();
35         list2.add(“a”);
36         list2.add(“b”);
37         //将list2添加到list中
38         list.addAll(list2);
39         //遍历
40         for (String string : list) {
41             System.out.println(string);
42         }
43     }
44 }

输出结果为:

 1 aaa
 2 bbb
 3 aaa
 4 ddd
 5 ccc
 6 null
 7 —————
 8 aaa
 9 bbb2
10 aaa
11 ddd
12 null
13 ————–
14 清空后list的大小0
15 a
16 b

由输出结果的1-5行可以看出，list存放元素的顺序与加入的顺序一致。

　　二、LinkedList

　　LinkedList通过代价较低的在List中间进行插入和删除操作，提供了优化的顺序访问。但是在随即访问方面相对比较慢。

　　下面举个例子来演示LinkedList和ArrayList随即访问的速度：

 1 package com.list;
 2
 3 import java.util.ArrayList;
 4 import java.util.LinkedList;
 5 import java.util.List;
 6 import java.util.Random;
 7
 8 public class LinkedListTest {
 9     public static void main(String[] args) {
10         List arraylist = new ArrayList();
11         for (int i = 0; i < 5000; i++) {
12             arraylist.add(i);
13         }
14         List linkedlist = new LinkedList();
15         for (int i = 0; i < 5000; i++) {
16             linkedlist.add(i);
17         }
18         Random rand = new Random(5000);
19         //随机访问arrayList
20         long start = System.currentTimeMillis();
21         for (long i = 0; i < 500000; i++) {
22             arraylist.get(rand.nextInt(5000));
23         }
24         long end = System.currentTimeMillis();
25         System.out.println(“arrayList随机访问时间：”+(end - start));
26         //随机访问arrayList
27         start = System.currentTimeMillis();
28         for (long i = 0; i < 500000; i++) {
29             linkedlist.get(rand.nextInt(5000));
30         }
31         end = System.currentTimeMillis();
32         System.out.println(“linkedlist随机访问时间：”+(end - start));
33     }
34 }

程序运行结果为：

1 arrayList随机访问时间：20
2 linkedlist随机访问时间：2282

很明显ArrayList随即访问比LinkedList快的多，因为LinkedList是以链表的现实存储的。