Java中 ArrayList、Vector和LinkedList 的使用和详解！

  1 import java.util.*;
  2 
  3 /**
  4  * （1）ArrayList是最常用的List实现类，内部是通过数组实现的，它允许对元素进行快速随机访问。数组的缺点是每个元素之间不能含有“空隙”。
  5  * 当数组大小不满足时会增加存储能力，将已有数组数据复制到新的存储空间中。当从ArrayList的中间位置插入或者删除元素时，需要对数组进行拷贝，移动，代价比较高。因此，它适合随即查找和遍历，不适合插入合删除。
  6  * （2）Vector与ArrayList一样，也是通过数组实现的。不同的是它支持线程的同步，
  7  * 即一时刻只有一个线程能够写Vector，避免多线程同时写引起的不一致性。但实现同步需要很高的花费， 因此，访问它比访问ArrayList慢。
  8  * （3）LinkedList是用链表结构存储数据的，很适合数据的动态插入和删除，随即访问和遍历速度比较慢。另外，它还提供了List没有定义的方法，专门用于操作表头和表尾元素，可以当作堆栈、队列和双向队列使用。
  9  * （4）因为ArrayList和Vector都是用数组实现的，所以，在添加和插入时，最好从表尾操作，而不要从中间或者表头开始，以避免数组移动引起的开销！
 10  * （5）可以为每个List生成ListIterator，支持双向遍历List，而且能够在ListIterator位置插入和删除元素。
 11  * （6）堆栈类继承Vector，它总是对列表的尾部数据进行操作，采用了先进后出的策略，自定义了插入、查看和弹出元素三个方法。 ArrayList 性能测试。
 12  * 
 13  * @author sun
 14  */
 15 public class TestList {
 16 
 17     /**
 18      * 初始化一个List
 19      * 
 20      * @param list
 21      */
 22     public static void init(List list) {
 23         if (list != null) {
 24             list.add("aaa");
 25             list.add("ccc");
 26             list.add("bbb");
 27             list.add("eee");
 28             list.add("ddd");
 29         }
 30     }
 31 
 32     /**
 33      * 输出List的内容
 34      * 
 35      * @param list
 36      */
 37     public static void output(List list) {
 38         if (list != null) {
 39             // 根据列表下标遍历，使用list.size()获取列表中元素的个数
 40             for (int i = 0; i < list.size(); i++) {
 41                 System.out.print(list.get(i) + "  ");
 42             }
 43             System.out.println();
 44             // 或者用迭代器遍历
 45             Iterator it = list.iterator();
 46             Object value = null;
 47             while (it.hasNext()) {
 48                 value = it.next();
 49                 System.out.print(value + "  ");
 50             }
 51         }
 52         System.out.println();
 53     }
 54 
 55     /**
 56      * 使用ArrayList
 57      */
 58     public static void testArrayList() {
 59         List list = new ArrayList();
 60         init(list);
 61         System.out.println("使用ArrayList: ");
 62         output(list);
 63     }
 64 
 65     /**
 66      * 使用Vector
 67      */
 68     public static void testVector() {
 69         List list = new Vector();
 70         init(list);
 71         System.out.println("使用Vector: ");
 72         output(list);
 73     }
 74 
 75     /**
 76      * 使用LinkedList
 77      */
 78     public static void testLinkedList() {
 79         List list = new LinkedList();
 80         init(list);
 81         System.out.println("使用LinkedList: ");
 82         output(list);
 83     }
 84 
 85     public static void main(String[] args) {
 86         TestList.testArrayList();
 87         // TestList.testVector();
 88         // TestList.testLinkedList();
 89 
 90         List list = new ArrayList();
 91         init(list);
 92         // 1:List支持元素重复
 93         list.add("aaa");
 94         list.add("bbb");
 95         System.out.println("插入元素aaa, bbb后：");
 96         output(list);
 97         // 2:指定元素插入的位置
 98         list.add(1, "fff");
 99         System.out.println("在下标为1处插入fff后：");
100         output(list);
101         List list2 = new ArrayList();
102         list2.add("ggg");
103         list2.add("hhh");
104         // 将另一列表中的元素插入到列表中
105         list.addAll(list2);
106         System.out.println("添加list2的元素后：");
107         output(list);
108 
109         // 判断列表是否包含某一元素
110         // 通过元素的equals方法，判断元素是否相等
111         System.out.println("list包含aaa? " + list.contains("aaa"));
112         // 判断列表中是否包含了另外一个列表中的所有元素。
113         System.out.println("list包含list2中的所有元素? " + list.containsAll(list2));
114         // 定位一个元素在列表中最先出现的位置
115         System.out.println("aaa在list中第一次出现的位置: " + list.indexOf("aaa"));
116         // 定位一个元素在列表中最后出现的位置
117         System.out.println("aaa在list中最后一次出现的位置: " + list.lastIndexOf("aaa"));
118 
119         // 更新列表中某个位置的元素值
120         list.set(2, "xxx");
121         System.out.println("更新位置为2的元素为xxx后：");
122         output(list);
123         // 删除列表中的某个元素，只删除第一次出现的那个
124         list.remove("aaa");
125         System.out.println("删除元素aaa后：");
126         output(list);
127         // 删除列表中指定位置的元素
128         list.remove(1);
129         System.out.println("删除下标为1的元素后：");
130         output(list);
131         // 删除列表中的其他元素，只保留另一个列表中包含的元素
132         list.retainAll(list2);
133         System.out.println("删除除list2包含的以外的元素后：");
134         output(list);
135         // 删除列表中在另一列表中也包含了的元素
136         list.removeAll(list2);
137         System.out.println("删除list2包含的元素后：");
138         output(list);
139         // 清空列表
140         list.clear();
141         // 判断列表中是否有数据
142         System.out.println("清空List后，list为空么?  " + list.isEmpty());
143         /*
144          * ---------------------
145          */
146         init(list);
147         // 用列表中的某些元素构造一个新的列表
148         list2 = list.subList(1, 3);
149         System.out.println("用list的第1个到第3个元素构造一个新的List:");
150         output(list2);
151 
152         // 用List特有的遍历器ListIterator遍历列表
153         // 与普通的Iterator不用，它允许两个方向遍历列表
154         ListIterator listIt = list.listIterator();
155         System.out.println("正向遍历列表");
156         while (listIt.hasNext()) {
157             System.out.print(listIt.next() + "  ");
158         }
159         System.out.println();
160         System.out.println("反向遍历列表");
161         while (listIt.hasPrevious()) {
162             System.out.print(listIt.previous() + "  ");
163         }
164         System.out.println();
165         // 也可以使用ListIterator从List中间插入和删除元素，
166         // 只能在遍历器当前位置添加和删除。
167         listIt.add("newadd");
168         System.out.println("用ListIterator往列表中添加元素newadd后: ");
169         output(list);
170         listIt.next();
171         listIt.remove();
172         System.out.println("用ListIterator删除列表中元素后: ");
173         output(list);
174 
175         // LinkedList自定义的方法
176         LinkedList linklist = new LinkedList();
177         init(linklist);
178         // 添加元素到列表头
179         linklist.addFirst("fff");
180         System.out.println("把fff放到列表头：");
181         output(linklist);
182         // 添加元素到列表尾
183         linklist.addLast("eee");
184         System.out.println("把eee放到列表尾：");
185         output(linklist);
186         // 获取表头元素
187         System.out.println("列表头元素：" + linklist.getFirst());
188         // 获取表尾元素
189         System.out.println("列表尾元素：" + linklist.getLast());
190         // 删除列表头的元素
191         linklist.removeFirst();
192         System.out.println("删除列表头元素：");
193         output(linklist);
194         // 删除列表尾的元素
195         linklist.removeLast();
196         System.out.println("删除列表尾元素：");
197         output(linklist);
198 
199         // 堆栈Stack类，它继承自Stack类
200         Stack myStack = new Stack();
201         // 插入元素，是插入到尾部
202         myStack.push("aaa");
203         myStack.push("bbb");
204         myStack.push("ccc");
205         myStack.push("ddd");
206         myStack.push("eee");
207         myStack.push("fff");
208         myStack.push("ggg");
209         System.out.println("堆栈中的元素是: ");
210         output(myStack);
211         /* 查看堆栈顶部的对象，但不从堆栈中移除它。 */
212         System.out.println("堆栈尾部元素: " + myStack.peek());
213         /* 移除堆栈顶部的对象，并返回该对象作为此函数的值。 */
214         System.out.println("弹出堆栈尾部元素: " + myStack.pop());
215         System.out.println("再次弹出堆栈尾部元素: " + myStack.peek());
216         /* 把项压入堆栈顶部。 */
217         myStack.push("sun");
218         System.out.println("再一次弹出堆栈尾部元素: " + myStack.peek());
219         if (myStack.empty()) {
220             System.out.println("myStack为空！");
221         } else {
222             System.out.println("myStack不为空！");
223         }
224         /* 对象到堆栈顶部的位置，以 1 为基数；返回值 -1 表示此对象不在堆栈中。 */
225         System.out.println("返回对象在堆栈中的位置: " + myStack.search("fff"));
226 
227     }
228 }