Java LinkList遍历方式

1.LinkedList的遍历方式

a.一般的for循环(随机访问)

1. int size = list.size();
2. for (int i=0; i<size; i++) {
3. list.get(i);
4. }

b.for--each循环

1. for (Integer integ:list)
2. ;

c.迭代器iterator

1. for(Iterator iter = list.iterator(); iter.hasNext();)
2. iter.next();

d.用pollFirst()来遍历LinkedList

1. while(list.pollFirst() != null)
2. ;

e.用pollLast()来遍历LinkedList

1. while(list.pollLast() != null)
2. ;

f.用removeFirst()来遍历LinkedList

1. try {
2. while(list.removeFirst() != null)
3. ;
4. } catch (NoSuchElementException e) {
5. }

g.用removeLast()来遍历LinkedList

1. try {
2. while(list.removeLast() != null)
3. ;
4. } catch (NoSuchElementException e) {
5. }

LinkedList遍历效率分析：

1. package com.sheepmu;
2. import java.util.Iterator;
3. import java.util.LinkedList;
4. import java.util.NoSuchElementException;
5. /*
6. * @author SheepMu
7. */
8. public class LinkedListTest {
9. public static void main(String[] args) {
10. LinkedList<Integer> llist = new LinkedList<Integer>();
11. for (int i=0; i<100000; i++)
12. llist.addLast(i);
13. byCommonFor(llist) ;// 通过一般for循环来遍历LinkedList
14. byForEach(llist) ;  // 通过for-each来遍历LinkedList
15. byIterator(llist) ; // 通过Iterator来遍历LinkedList
16. byPollFirst(llist) ;    // 通过PollFirst()遍历LinkedList
17. byPollLast(llist) ; // 通过PollLast()遍历LinkedList
18. byRemoveFirst(llist) ;   // 通过removeFirst()遍历LinkedList
19. byRemoveLast(llist) ; // 通过removeLast()遍历LinkedList
20. }
21. private static void byCommonFor(LinkedList<Integer> list) {// 通过一般for循环来遍历LinkedList
22. if (list == null)
23. return ;
24. long start = System.currentTimeMillis();
25. int size = list.size();
26. for (int i=0; i<size; i++) {
27. list.get(i);
28. }
29. long end = System.currentTimeMillis();
30. long total = end - start;
31. System.out.println("byCommonFor------->" + total+" ms");
32. }
33. private static void byForEach(LinkedList<Integer> list) {// 通过for-each来遍历LinkedList
34. if (list == null)
35. return ;
36. long start = System.currentTimeMillis();
37. for (Integer integ:list)
38. ;
39. long end = System.currentTimeMillis();
40. long total = end - start;
41. System.out.println("byForEach------->" + total+" ms");
42. }
43. private static void byIterator(LinkedList<Integer> list) {// 通过Iterator来遍历LinkedList
44. if (list == null)
45. return ;
46. long start = System.currentTimeMillis();
47. for(Iterator iter = list.iterator(); iter.hasNext();)
48. iter.next();
49. long end = System.currentTimeMillis();
50. long total = end - start;
51. System.out.println("byIterator------->" + total+" ms");
52. }
53. private static void byPollFirst(LinkedList<Integer> list) {//通过PollFirst()遍历LinkedList
54. if (list == null)
55. return ;
56. long start = System.currentTimeMillis();
57. while(list.pollFirst() != null)
58. ;
59. long end = System.currentTimeMillis();
60. long total = end - start;
61. System.out.println("byPollFirst------->" + total+" ms");
62. }
63. private static void byPollLast(LinkedList<Integer> list) {// 通过PollLast()遍历LinkedList
64. if (list == null)
65. return ;
66. long start = System.currentTimeMillis();
67. while(list.pollLast() != null)
68. ;
69. long end = System.currentTimeMillis();
70. long total = end - start;
71. System.out.println("byPollLast------->" + total+" ms");
72. }
73. private static void byRemoveFirst(LinkedList<Integer> list) {// 通过removeFirst()遍历LinkedList
74. if (list == null)
75. return ;
76. long start = System.currentTimeMillis();
77. try {
78. while(list.removeFirst() != null)
79. ;
80. } catch (NoSuchElementException e) {
81. }
82. long end = System.currentTimeMillis();
83. long total = end - start;
84. System.out.println("byRemoveFirst------->" + total+" ms");
85. }
86. private static void byRemoveLast(LinkedList<Integer> list) {// 通过removeLast()遍历LinkedList
87. if (list == null)
88. return ;
89. long start = System.currentTimeMillis();
90. try {
91. while(list.removeLast() != null)
92. ;
93. } catch (NoSuchElementException e) {
94. }
95. long end = System.currentTimeMillis();
96. long total = end - start;
97. System.out.println("byRemoveLast------->" + total+" ms");
98. }
99. }

byCommonFor------->5342 ms
byForEach------->11 ms
byIterator------->8 ms
byPollFirst------->4 ms
byPollLast------->0 ms
byRemoveFirst------->0 ms
byRemoveLast------->0 ms
由此可见，遍历LinkedList时，使用removeFist()或removeLast()效率最高。但用它们遍历时，会删除原始数据；若单纯只读取，而不删除，LinkedList遍历时建议使用For-each或者迭代器的方式。千万不要通过随机访问去遍历LinkedList！

 

2.LinkedList应用举例

a.LinkedList常用方法举例

1. package com.sheepmu;
2. import java.util.LinkedList;
3. /*
4. * @author SheepMu
5. */
6. public class LinkedListTest {
7. public static void main(String[] args) {
8. commonMethods() ; // 测试LinkedList的常用方法
9. likeStack();// 将LinkedList当作 LIFO(后进先出)的堆栈
10. likeQueue(); // 将LinkedList当作 FIFO(先进先出)的队列
11. }
12. private static void commonMethods() {
13. LinkedList<String> llist = new LinkedList<String>();
14. llist.add("A");//添加元素
15. llist.add("B");
16. llist.add("C");
17. llist.add("D");
18. System.out.println("llist------->"+llist);
19. llist.add(1, "E");// 将“E”添加到第索引为1的个位置
20. System.out.println("添加E到索引为1的个位置后的llist------->"+llist);
21. llist.addFirst("X");//  将“X”添加到第一个位置。  失败的话，抛出异常！
22. System.out.println("在最前面添加X后的llist------->"+llist);
23. System.out.println("删除第一个元素并获得并返回被删除元素----->"+llist.removeFirst());  // 将第一个元素删除。
24. System.out.println("删除第一个元素后的llist------->"+llist);
25. llist.offerFirst("Y");// 将“Y”添加到第一个位置。  返回true。
26. System.out.println("将Y添加到第一个位置后的llist------->"+llist);
27. System.out.println("删除第一个元素并获得并返回被删除元素------>"+llist.pollFirst()); // 将第一个元素删除。
28. System.out.println("将第一个元素删除后的llist------->"+llist);
29. llist.removeLast() ;
30. System.out.println("移除最后一个元素后的llist------->"+llist);
31. llist.offerLast("Z"); //   将“Z”添加到最后一个位置
32. System.out.println("在最后添加Z后的llist------->"+llist);
33. llist.set(2, "M");// 将第3个元素设置M。
34. System.out.println("将第3个元素设置M后的llist------->"+llist);
35. System.out.println("size:"+llist.size());// LinkedList大小
36. llist.clear();// 清空LinkedList
37. }
38. private static void likeStack() { //将LinkedList作为栈使用!!!!!!!!!!!!
39. LinkedList<String> stack = new LinkedList<String>();
40. stack.push("A");//向栈中添加元素
41. stack.push("B");
42. stack.push("C");
43. stack.push("D");
44. System.out.println("stack--------->"+stack);
45. stack.pop() ;// 删除“栈顶元素”
46. System.out.println("删除栈顶后的stack--------->"+stack);
47. System.out.println("栈顶元素--------->"+stack.peek()); // 取出栈顶
48. }
49. private static void likeQueue() {//将LinkedList作为队列使用!!!!!!!!!!!!
50. LinkedList<String> queue = new LinkedList<String>();
51. queue.add("A");//向队列中添加元素
52. queue.add("B");
53. queue.add("C");
54. queue.add("D");
55. System.out.println("queue--------->"+queue);
56. queue.remove() ;//删除队列的第一个元素
57. System.out.println("删除队列的第一个元素后queue--------->"+queue);
58. System.out.println("队列第一个元素------->"+queue.element()); // 读取队列的第一个元素
59. }
60. }

llist------->[A, B, C, D]
添加E到索引为1的个位置后的llist------->[A, E, B, C, D]
在最前面添加X后的llist------->[X, A, E, B, C, D]
删除第一个元素并获得并返回被删除元素----->X
删除第一个元素后的llist------->[A, E, B, C, D]
将Y添加到第一个位置后的llist------->[Y, A, E, B, C, D]
删除第一个元素并获得并返回被删除元素------>Y
将第一个元素删除后的llist------->[A, E, B, C, D]
移除最后一个元素后的llist------->[A, E, B, C]
在最后添加Z后的llist------->[A, E, B, C, Z]
将第3个元素设置M后的llist------->[A, E, M, C, Z]
size:5
stack--------->[D, C, B, A]
删除栈顶后的stack--------->[C, B, A]
栈顶元素--------->C
queue--------->[A, B, C, D]
删除队列的第一个元素后queue--------->[B, C, D]
队列第一个元素------->B