java開發(fā)過程中，用到的最多的List集合就屬ArrayList與LinkedList。對于ArrayList的遍歷，通常是下面的方法：
|
1
2
3
4
5
6
7
8
9
10
|
public static void main(String[] args){ List<Integer> arrayList = new ArrayList<Integer>(); for (int i = 0; i < 100; i++) arrayList.add(i); for (int i = 0; i < 100; i++) System.out.println(arrayList.get(i));} |
假如集合換成LinkedList，可能我們就會用相同得方法進行遍歷，如下：
|
1
2
3
4
5
6
7
8
9
10
|
public static void main(String[] args){ List<Integer> linkedList = new LinkedList<Integer>(); for (int i = 0; i < 100; i++) linkedList.add(i); for (int i = 0; i < 100; i++) System.out.println(linkedList.get(i));} |
請記?。?span style="color: #ff0000">這是一種非常糟糕的做法。這其實已經(jīng)不是Java的問題，而是數(shù)據(jù)結(jié)構(gòu)的問題了，我相信語言從Java換成其他的也都一樣。
下面對ArrayList和LinkedList的普通for循環(huán)效率進行測試以及分析原因。
ArrayList和LinkedList使用普通for循環(huán)遍歷速度對比
先給出測試代碼：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
public class ListIteratorTest{ private final static int LIST_SIZE = 1000; public static void main(String[] args) { List<Integer> arrayList = new ArrayList<Integer>(); List<Integer> linkedList = new LinkedList<Integer>(); for (int i = 0; i < LIST_SIZE; i++) { arrayList.add(i); linkedList.add(i); } long startTime = System.currentTimeMillis(); for (int i = 0; i < arrayList.size(); i++) arrayList.get(i); System.out.println("ArrayList遍歷速度：" + (System.currentTimeMillis() - startTime) + "ms"); startTime = System.currentTimeMillis(); for (int i = 0; i < linkedList.size(); i++) linkedList.get(i); System.out.println("LinkedList遍歷速度：" + (System.currentTimeMillis() - startTime) + "ms"); }} |
不斷增大LIST_SIZE，我用表格表示一下運行結(jié)果：
| 1000 | 5000 | 10000 | 50000 | 100000 | |
| ArrayList | 0ms | 1ms | 2ms | 3ms | 3ms |
| LinkedList | 3ms | 16ms | 88ms | 2446ms | 18848ms |
下面解釋一下產(chǎn)生此現(xiàn)象的原因。從運行結(jié)果我們看到，按倍數(shù)增大List容量，ArrayList的遍歷顯得比較穩(wěn)定，而LinkedList的遍歷幾乎是爆發(fā)式的增長，再測試下去已經(jīng)沒有必要了。
ArrayList使用普通for循環(huán)遍歷快的原因
先看一下ArrayList的get方法源代碼：
|
1
2
3
4
5
|
public E get(int index) {RangeCheck(index);return (E) elementData[index];} |
看到ArrayList的get方法只是從數(shù)組里面拿一個位置上的元素罷了。我們有結(jié)論，ArrayList的get方法的時間復雜度是O(1)，O(1)的意思也就是說時間復雜度是一個常數(shù)，和數(shù)組的大小并沒有關(guān)系，只要給定數(shù)組的位置，直接就能定位到數(shù)據(jù)。
其實熟悉C、C++或者對指針理解的朋友一定很好理解為什么，我解釋一下為什么對數(shù)組使用get就快。
在計算機底層，數(shù)據(jù)都是有地址的，就像人有住址一樣。假設(shè)我寫了這么一句代碼：
|
1
|
int[3] ints = {1, 3, 5}; |
在Java中一個int型數(shù)據(jù)是4個字節(jié)，此時計算機內(nèi)部做的事情是，在內(nèi)存空間中找到一塊連續(xù)的、足以存放3個4字節(jié)也就是12字節(jié)的數(shù)組的內(nèi)存空間，并返回該內(nèi)存空間的首地址。比方說該內(nèi)存空間的首地址是0x00吧，那么那么1就放在0x00~0x03中、3就放在0x04~0x07中、5就放在0x08~0x0B中。
這時就很簡單了，取ints[1]的時候，計算機就會算出ints[1]的數(shù)據(jù)是存放在以0x04開頭，占據(jù)4個字節(jié)空間的內(nèi)存中，因此，計算機會從0x04~0x07這塊地址空間中讀取數(shù)據(jù)出來。
整個過程，和數(shù)組有多大，并沒有關(guān)系，計算機做的只是算出起始地址-->去該地址中取數(shù)據(jù)而已，因此我們看到使用普通for循環(huán)遍歷ArrayList的速度很快，也很穩(wěn)定。
LinkedList使用普通for循環(huán)遍歷慢的原因
再看一下LinkedList的get方法做了什么：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
public E get(int index) { return entry(index).element;} Node<E> node(int index) { // assert isElementIndex(index); if (index < (size >> 1)) { Node<E> x = first; for (int i = 0; i < index; i++) x = x.next; return x; } else { Node<E> x = last; for (int i = size - 1; i > index; i--) x = x.prev; return x; } } |
由于LinkedList是雙向鏈表，因此第4行的意思是算出i在一半前還是一半后，一半前正序遍歷、一半后倒序遍歷，這樣會快很多，當然，先不管這個，分析一下為什么使用普通for循環(huán)遍歷LinkedList會這么慢。
原因就在第6~第7行，第11~第12行的兩個for循里面，以前者為例：
1、get(0)，直接拿到0位的Node0的地址，拿到Node0里面的數(shù)據(jù)
2、get(1)，直接拿到0位的Node0的地址，從0位的Node0中找到下一個1位的Node1的地址，找到Node1，拿到Node1里面的數(shù)據(jù)
3、get(2)，直接拿到0位的Node0的地址，從0位的Node0中找到下一個1位的Node1的地址，找到Node1，從1位的Node1中找到下一個2位的Node2的地址，找到Node2，拿到Node2里面的數(shù)據(jù)。
后面的以此類推。
也就是說，LinkedList在get任何一個位置的數(shù)據(jù)的時候，都會把前面的數(shù)據(jù)走一遍。假如我有10個數(shù)據(jù)，那么將要查詢1+2+3+4+5+5+4+3+2+1=30次數(shù)據(jù)，相比ArrayList，卻只需要查詢10次數(shù)據(jù)就行了，隨著LinkedList的容量越大，差距會越拉越大。其實使用LinkedList到底要查詢多少次數(shù)據(jù)，大家應該已經(jīng)很明白了，來算一下：按照前一半算應該是（1 + 0.5N） * 0.5N / 2，后一半算上即乘以2，應該是（1 + 0.5N） * 0.5N = 0.25N2 + 0.5N，忽略低階項和首項系數(shù)，得出結(jié)論，LinikedList遍歷的時間復雜度為O(N2)，N為LinkedList的容量。
時間復雜度有以下經(jīng)驗規(guī)則：
O(1) < O(log2N) < O(n) < O(N * log2N) < O(N2) < O(N3) < 2N < 3N < N!
前四個比較好、中間兩個一般、后3個很爛。也就是說O(N2)是相對糟糕的一種時間復雜度了，N大一點，程序就會執(zhí)行得比較慢。
后記
切記一定不要使用普通for循環(huán)去遍歷LinkedList。使用迭代器或者foreach循環(huán)（foreach循環(huán)的原理就是迭代器）去遍歷LinkedList即可，這種方式是直接按照地址去找數(shù)據(jù)的，將會大大提升遍歷LinkedList的效率。
以上這篇淺談普通for循環(huán)遍歷LinkedList弊端就是小編分享給大家的全部內(nèi)容了，希望能給大家一個參考，也希望大家多多支持服務器之家。
