疯狂JAVA讲义---第七章（中）：集合List，Queue（转）

List是我们所有集合中最多的，也可以说太好用了。相比set他提供了索引，我们可以通过索引得到元素，元素可以重复。使用时要记住set方法不能改变List长度，而romove时会将后面的元素提上来，eg

1. public class TestList
2. {
3.     public static void main(String[] args) 
4.     {
5.         List books = new ArrayList();
6.         //向books集合中添加三个元素
7.         books.add(new String("轻量级J2EE企业应用实战"));
8.         books.add(new String("Struts2权威指南"));
9.         books.add(new String("基于J2EE的Ajax宝典"));
10.         System.out.println(books);
11.         //将新字符串对象插入在第二个位置
12.         books.add(1 , new String("ROR敏捷开发最佳实践"));
13.         for (int i = 0 ; i < books.size() ; i++ )
14.         {
15.             System.out.println(books.get(i));
16.         }
17.         //删除第三个元素
18.         books.remove(2);
19.         System.out.println(books);
20.         //判断指定元素在List集合中位置：输出1，表明位于第二位
21.         System.out.println(books.indexOf(new String("ROR敏捷开发最佳实践")));
22.         //将第二个元素替换成新的字符串对象
23.         books.set(1, new String("Struts2权威指南"));
24.         System.out.println(books);
25.         //将books集合的第二个元素（包括）到第三个元素（不包括）截取称子集合
26.         System.out.println(books.subList(1 , 2));
27. 
    
28.     }
29. }

 

 

ListIterator是其专用迭代器，不但有next还有previous方法，就是说可以向前迭代，非常方便。eg

1. public class TestListIterator
2. {
3.     public static void main(String[] args) 
4.     {
5.         String[] books = {
6.             "Struts2权威指南",
7.             "轻量级J2EE企业应用实战"
8.         };
9.         List bookList = new ArrayList();
10.         for (int i = 0; i < books.length ; i++ )
11.         {
12.             bookList.add(books[i]);
13.         }
14.         ListIterator lit = bookList.listIterator();
15.         while (lit.hasNext())
16.         {
17.             System.out.println(lit.next());
18.             lit.add("-------分隔符-------");
19.         }
20.         System.out.println("==========下面开始反向迭代===========");
21.         while(lit.hasPrevious())
22.         {
23.             System.out.println(lit.previous());
24.         }
25.     }
26. }

list的实现类分为ArrayList 和Vector,但vector已经过时，尽量少用。只是vector的子类stack还有用武之地。eg

1. public class TestVector
2. {
3.     public static void main(String[] args) 
4.     {
5.         Stack v = new Stack();
6.         //依次将三个元素push入"栈"
7.         v.push("Struts2权威指南");
8.         v.push("轻量级J2EE企业应用实战");
9.         v.push("ROR敏捷开发最佳实践");
10.         //输出：[Struts2权威指南, 轻量级J2EE企业应用实战, ROR敏捷开发最佳实践]
11.         System.out.println(v);
12.         //访问第一个元素，但并不将其pop出"栈"，输出：ROR敏捷开发最佳实践
13.         System.out.println(v.peek());
14.         //依然输出：[Struts2权威指南, 轻量级J2EE企业应用实战, ROR敏捷开发最佳实践]
15.         System.out.println(v);
16.         //pop出第一个元素，输出：ROR敏捷开发最佳实践
17.         System.out.println(v.pop());
18.         //依然输出：[Struts2权威指南, 轻量级J2EE企业应用实战]
19.         System.out.println(v);
20.     }
21. }

LinkedList这是一个特殊集合，他既可以当list用也可以当queue用。eg（请使用jdk1.6）

1. public class TestLinkedList
2. {
3.     public static void main(String[] args) 
4.     {
5.         LinkedList books = new LinkedList();
6.         //将字符串元素加入队列的尾部
7.         books.offer("Struts2权威指南");
8.         //将一个字符串元素入栈
9.         books.push("轻量级J2EE企业应用实战");
10.         //将字符串元素添加到队列的头部
11.         books.offerFirst("ROR敏捷开发最佳实践");
12.         for (int i = 0; i < books.size() ; i++ )
13.         {
14.             System.out.println(books.get(i));
15.         }
16.         //访问、并不删除队列的第一个元素
17.         System.out.println(books.peekFirst());
18.         //访问、并不删除队列的最后一个元素
19.         System.out.println(books.peekLast());
20.         //采用出栈的方式将第一个元素pop出队列
21.         System.out.println(books.pop());
22.         //下面输出将看到队列中第一个元素被删除
23.         System.out.println(books);
24.         //访问、并删除队列的最后一个元素
25.         System.out.println(books.pollLast());
26.         //下面输出将看到队列中只剩下中间一个元素：轻量级J2EE企业应用实战
27.         System.out.println(books);
28. 
    
29.     }
30. }
31. 
    

虽然LinkedList功能强大，但是效率低，通过下面的例子大家能看出差距。eg

1. public class TestPerformance
2. {
3.     public static void main(String[] args) 
4.     {
5.         //创建一个字符串数组
6.         String[] tst1 = new String[900000];
7.         //动态初始化数组元素
8.         for (int i = 0; i < 900000; i++)
9.         {
10.             tst1[i] = String.valueOf(i);
11.         }
12.         ArrayList al = new ArrayList();
13.         //将所有数组元素加入ArrayList集合中
14.         for (int i = 0; i < 900000 ; i++)
15.         {
16.             al.add(tst1[i]);
17.         }
18.         LinkedList ll = new LinkedList();
19.         //将所有数组元素加入LinkedList集合中
20.         for (int i = 0; i < 900000 ; i++)
21.         {
22.             ll.add(tst1[i]);
23.         }
24.         //迭代访问ArrayList集合的所有元素，并输出迭代时间
25.         long start = System.currentTimeMillis();
26.         for (Iterator it = al.iterator();it.hasNext() ; )
27.         {
28.             it.next();
29.         }
30.         System.out.println("迭代ArrayList集合元素的时间:" + (System.currentTimeMillis() - start));
31.         //迭代访问LinkedList集合的所有元素，并输出迭代时间
32.         start = System.currentTimeMillis();
33.         for (Iterator it = ll.iterator();it.hasNext() ; )
34.         {
35.             it.next();
36.         }
37.         System.out.println("迭代LinkedList集合元素的时间:" + (System.currentTimeMillis() - start));
38.     }
39. }

归根到底：ArrayList和vector底层都是用数组实现，而LinkedList是用链表实现