List集合底層實現

時間 2019-11-30

標籤 list 集合底層實現欄目快樂工作简体版

原文原文鏈接

1.List：

List實現Collection接口，它的數據結構是有序能夠重複的結合，該結合的體系有索引；它有三個實現類：ArrayList、LinkList、Vector三個實現類；

三個實現類的區別：

ArrayList:底層數據結構使數組結構，查詢速度快，增刪改慢，java

LinkList:底層使用鏈表結構，增刪速度快，查詢稍慢；數組

Vector：底層是數組結構，線程同步ArrayList是線程不一樣步；安全

可變長度數組不斷new數組：數據結構

ArrayList當初始化容量超過10時，會new一個50%de ,把原來的東西放入這150%中；併發

Vector：當容量超過10時，會new一個100%的浪費內存；異步

List接口對Collection進行了簡單的擴充，它的具體實現類經常使用的有ArrayList和LinkedList。你能夠將任何東西放到一個List容器中，並在須要時從中取出。ArrayList從其命名中能夠看出它是一種相似數組的形式進行存儲，所以它的隨機訪問速度極快，而LinkedList的內部實現是鏈表，它適合於在鏈表中間須要頻繁進行插入和刪除操做。在具體應用時能夠根據須要自由選擇。前面說的Iterator只能對容器進行向前遍歷，而ListIterator則繼承了Iterator的思想，並提供了對List進行雙向遍歷的方法。函數

2.ArrayList學習

1. ArrayList概述：優化

   ArrayList是List接口的可變數組的實現。實現了全部可選列表操做，並容許包括 null 在內的全部元素。除了實現 List 接口外，此類還提供一些方法來操做內部用來存儲列表的數組的大小。
   每一個ArrayList實例都有一個容量，該容量是指用來存儲列表元素的數組的大小。它老是至少等於列表的大小。隨着向ArrayList中不斷添加元素，其容量也自動增加。自動增加會帶來數據向新數組的從新拷貝，所以，若是可預知數據量的多少，可在構造ArrayList時指定其容量。在添加大量元素前，應用程序也可使用ensureCapacity操做來增長ArrayList實例的容量，這能夠減小遞增式再分配的數量。
   注意，此實現不是同步的。若是多個線程同時訪問一個ArrayList實例，而其中至少一個線程從結構上修改了列表，那麼它必須保持外部同步。this

2. ArrayList的實現：

對於ArrayList而言，它實現List接口、底層使用數組保存全部元素。其操做基本上是對數組的操做。下面咱們來分析ArrayList的源代碼：底層使用數組實現

Java代碼

private transient Object[] elementData;

2)構造方法：
ArrayList提供了三種方式的構造器，能夠構造一個默認初始容量爲10的空列表、構造一個指定初始容量的空列表以及構造一個包含指定collection的元素的列表，這些元素按照該collection的迭代器返回它們的順序排列的。

Java代碼

1. public ArrayList() {

2. this(10);

3. }

5. public ArrayList(int initialCapacity) {

6. super();

7. if (initialCapacity < 0)

8. throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);

9. this.elementData = new Object[initialCapacity];

10. }

11.

12. public ArrayList(Collection<? extends E> c) {

13. elementData = c.toArray();

14. size = elementData.length;

15. // c.toArray might (incorrectly) not return Object[] (see 6260652)

16. if (elementData.getClass() != Object[].class)

17. elementData = Arrays.copyOf(elementData, size, Object[].class);

18. }

3)存儲：
ArrayList提供了set(int index, E element)、add(E e)、add(int index, E element)、addAll(Collection<?extends E> c)、addAll(int index, Collection<?extends E> c)這些添加元素的方法。下面咱們一一講解：

Java代碼

1. // 用指定的元素替代此列表中指定位置上的元素，並返回之前位於該位置上的元素。

2. public E set(int index, E element) {

3. RangeCheck(index);

5. E oldValue = (E) elementData[index];

6. elementData[index] = element;

7. return oldValue;

8. }

Java代碼

1. // 將指定的元素添加到此列表的尾部。

2. public boolean add(E e) {

3. ensureCapacity(size + 1);

4. elementData[size++] = e;

5. return true;

6. }

Java代碼

1. // 將指定的元素插入此列表中的指定位置。

2. // 若是當前位置有元素，則向右移動當前位於該位置的元素以及全部後續元素（將其索引加1）。

3. public void add(int index, E element) {

4. if (index > size || index < 0)

5. throw new IndexOutOfBoundsException("Index: "+index+", Size: "+size);

6. // 若是數組長度不足，將進行擴容。

7. ensureCapacity(size+1); // Increments modCount!!

8. // 將 elementData中從Index位置開始、長度爲size-index的元素，

9. // 拷貝到從下標爲index+1位置開始的新的elementData數組中。

10. // 即將當前位於該位置的元素以及全部後續元素右移一個位置。

11. System.arraycopy(elementData, index, elementData, index + 1, size - index);

12. elementData[index] = element;

13. size++;

14. }

Java代碼

1. // 按照指定collection的迭代器所返回的元素順序，將該collection中的全部元素添加到此列表的尾部。

2. public boolean addAll(Collection<? extends E> c) {

3. Object[] a = c.toArray();

4. int numNew = a.length;

5. ensureCapacity(size + numNew); // Increments modCount

6. System.arraycopy(a, 0, elementData, size, numNew);

7. size += numNew;

8. return numNew != 0;

9. }

Java代碼

1. // 從指定的位置開始，將指定collection中的全部元素插入到此列表中。

2. public boolean addAll(int index, Collection<? extends E> c) {

3. if (index > size || index < 0)

4. throw new IndexOutOfBoundsException(

5. "Index: " + index + ", Size: " + size);

7. Object[] a = c.toArray();

8. int numNew = a.length;

9. ensureCapacity(size + numNew); // Increments modCount

10.

11. int numMoved = size - index;

12. if (numMoved > 0)

13. System.arraycopy(elementData, index, elementData, index + numNew, numMoved);

14.

15. System.arraycopy(a, 0, elementData, index, numNew);

16. size += numNew;

17. return numNew != 0;

}

讀取

Java代碼

1. // 返回此列表中指定位置上的元素。

2. public E get(int index) {

3. RangeCheck(index);

5. return (E) elementData[index];

6. }

5) 刪除：
ArrayList提供了根據下標或者指定對象兩種方式的刪除功能。以下：

Java代碼

1. // 移除此列表中指定位置上的元素。

2. public E remove(int index) {

3. RangeCheck(index);

5. modCount++;

6. E oldValue = (E) elementData[index];

8. int numMoved = size - index - 1;

9. if (numMoved > 0)

10. System.arraycopy(elementData, index+1, elementData, index, numMoved);

11. elementData[--size] = null; // Let gc do its work

12.

13. return oldValue;

14. }

Java代碼

1. // 移除此列表中首次出現的指定元素（若是存在）。這是應爲ArrayList中容許存放重複的元素。

2. public boolean remove(Object o) {

3. // 因爲ArrayList中容許存放null，所以下面經過兩種狀況來分別處理。

4. if (o == null) {

5. for (int index = 0; index < size; index++)

6. if (elementData[index] == null) {

7. // 相似remove(int index)，移除列表中指定位置上的元素。

8. fastRemove(index);

9. return true;

10. }

11. } else {

12. for (int index = 0; index < size; index++)

13. if (o.equals(elementData[index])) {

14. fastRemove(index);

15. return true;

16. }

17. }

18. return false;

19. }

    注意：從數組中移除元素的操做，也會致使被移除的元素之後的全部元素的向左移動一個位置。
   6) 調整數組容量：
   從上面介紹的向ArrayList中存儲元素的代碼中，咱們看到，每當向數組中添加元素時，都要去檢查添加後元素的個數是否會超出當前數組的長度，若是超出，數組將會進行擴容，以知足添加數據的需求。數組擴容經過一個公開的方法ensureCapacity(int minCapacity)來實現。在實際添加大量元素前，我也可使用ensureCapacity來手動增長ArrayList實例的容量，以減小遞增式再分配的數量。

Java代碼

1. public void ensureCapacity(int minCapacity) {

2. modCount++;

3. int oldCapacity = elementData.length;

4. if (minCapacity > oldCapacity) {

5. Object oldData[] = elementData;

6. int newCapacity = (oldCapacity * 3)/2 + 1;

7. if (newCapacity < minCapacity)

8. newCapacity = minCapacity;

9. // minCapacity is usually close to size, so this is a win:

10. elementData = Arrays.copyOf(elementData, newCapacity);

11. }

12. }

從上述代碼中能夠看出，數組進行擴容時，會將老數組中的元素從新拷貝一份到新的數組中，每次數組容量的增加大約是其原容量的1.5倍。這種操做的代價是很高的，所以在實際使用時，咱們應該儘可能避免數組容量的擴張。當咱們可預知要保存的元素的多少時，要在構造ArrayList實例時，就指定其容量，以免數組擴容的發生。或者根據實際需求，經過調用ensureCapacity方法來手動增長ArrayList實例的容量。
ArrayList還給咱們提供了將底層數組的容量調整爲當前列表保存的實際元素的大小的功能。它能夠經過trimToSize方法來實現。代碼以下：

Java代碼

1. public void trimToSize() {

2. modCount++;

3. int oldCapacity = elementData.length;

4. if (size < oldCapacity) {

5. elementData = Arrays.copyOf(elementData, size);

6. }

7. }

7) Fail-Fast機制：
ArrayList也採用了快速失敗的機制，經過記錄modCount參數來實現。在面對併發的修改時，迭代器很快就會徹底失敗，而不是冒着在未來某個不肯定時間發生任意不肯定行爲的風險。具體介紹請參考我以前的文章深刻Java集合學習系列：HashMap的實現原理中的Fail-Fast機制。
8) 關於其餘的一些方法的實現都很簡單易懂，讀者可參照API文檔和源代碼，一看便知，這裏就再也不多說。

ArrayList和Vector的區別：

1.Vector是線程同步的，因此它也是線程安全的。而ArratList是線程異步的，不安全。若是不考慮安全因素，通常用Arralist效率比較高，查看JDK文檔，給出提示：

若是要實現Arraylist線程同步，能夠經過下面方式：

若是多個線程同時訪問一個 ArrayList 實例，而其中至少一個線程從結構上修改了列表，那麼它必須保持外部同步。（結構上的修改是指任何添加或刪除一個或多個元素的操做，或者顯式調整底層數組的大小；僅僅設置元素的值不是結構上的修改。）這通常經過對天然封裝該列表的對象進行同步操做來完成。若是不存在這樣的對象，則應該使用Collections.synchronizedList 方法將該列表「包裝」起來。這最好在建立時完成，以防止意外對列表進行不一樣步的訪問：

        List list = Collections.synchronizedList(new ArrayList(...));

2.若是集合中的元素數量大於當前集合數組的長度時，Vector的增加率是目前數組長度的100%，而ArryaList增加率爲目前數組長度的50%。因此，若是集合中使用數據量比較大的數據，用Vector有必定優點。

3.linkList

LinkedList與Collection關係以下圖：

LinkedList的本質是雙向鏈表。

(01) LinkedList繼承於AbstractSequentialList，而且實現了Dequeue接口。

(02) LinkedList包含兩個重要的成員：header 和 size。

　　header是雙向鏈表的表頭，它是雙向鏈表節點所對應的類Entry的實例。Entry中包含成員變量： previous, next, element。其中，previous是該節點的上一個節點，next是該節點的下一個節點，element是該節點所包含的值。

　　size是雙向鏈表中節點的個數。

第3部分 LinkedList源碼解析(基於JDK1.6.0_45)

爲了更瞭解LinkedList的原理，下面對LinkedList源碼代碼做出分析。

在閱讀源碼以前，咱們先對LinkedList的總體實現進行大體說明：

LinkedList其實是經過雙向鏈表去實現的。既然是雙向鏈表，那麼它的順序訪問會很是高效，而隨機訪問效率比較低。

既然LinkedList是經過雙向鏈表的，可是它也實現了List接口{也就是說，它實現了get(int location)、remove(int location)等「根據索引值來獲取、刪除節點的函數」}。LinkedList是如何實現List的這些接口的，如何將「雙向鏈表和索引值聯繫起來的」？

實際原理很是簡單，它就是經過一個計數索引值來實現的。例如，當咱們調用get(int location)時，首先會比較「location」和「雙向鏈表長度的1/2」；若前者大，則從鏈表頭開始日後查找，直到location位置；不然，從鏈表末尾開始先前查找，直到location位置。

這就是「雙線鏈表和索引值聯繫起來」的方法。

好了，接下來開始閱讀源碼(只要理解雙向鏈表，那麼LinkedList的源碼很容易理解的)。

複製代碼

1 package java.util;

3 public class LinkedList<E>

4 extends AbstractSequentialList<E>

5 implements List<E>, Deque<E>, Cloneable,java.io.Serializable

6 {

7 // 鏈表的表頭，表頭不包含任何數據。Entry是個鏈表類數據結構。

8 private transient Entry<E> header = new Entry<E>(null, null,null);

10 // LinkedList中元素個數

11 private transient int size = 0;

13 // 默認構造函數：建立一個空的鏈表

14 public LinkedList() {

15 header.next = header.previous = header;

16 }

18 // 包含「集合」的構造函數:建立一個包含「集合」的LinkedList

19 public LinkedList(Collection<? extends E> c) {

20 this();

21 addAll(c);

22 }

24 // 獲取LinkedList的第一個元素

25 public E getFirst() {

26 if (size==0)

27 throw newNoSuchElementException();

29 // 鏈表的表頭header中不包含數據。

30 // 這裏返回header所指下一個節點所包含的數據。

31 return header.next.element;

32 }

34 // 獲取LinkedList的最後一個元素

35 public E getLast() {

36 if (size==0)

37 throw new NoSuchElementException();

39 // 因爲LinkedList是雙向鏈表；而表頭header不包含數據。

40 // 於是，這裏返回表頭header的前一個節點所包含的數據。

41 return header.previous.element;

42 }

44 // 刪除LinkedList的第一個元素

45 public E removeFirst() {

46 return remove(header.next);

47 }

49 // 刪除LinkedList的最後一個元素

50 public E removeLast() {

51 return remove(header.previous);

52 }

54 // 將元素添加到LinkedList的起始位置

55 public void addFirst(E e) {

56 addBefore(e, header.next);

57 }

59 // 將元素添加到LinkedList的結束位置

60 public void addLast(E e) {

61 addBefore(e, header);

62 }

64 // 判斷LinkedList是否包含元素(o)

65 public boolean contains(Object o) {

66 return indexOf(o) != -1;

67 }

69 // 返回LinkedList的大小

70 public int size() {

71 return size;

72 }

74 // 將元素(E)添加到LinkedList中

75 public boolean add(E e) {

76 // 將節點(節點數據是e)添加到表頭(header)以前。

77 // 即，將節點添加到雙向鏈表的末端。

78 addBefore(e, header);

79 return true;

80 }

82 // 從LinkedList中刪除元素(o)

83 // 從鏈表開始查找，如存在元素(o)則刪除該元素並返回true；

84 // 不然，返回false。

85 public boolean remove(Object o) {

86 if (o==null) {

87 // 若o爲null的刪除狀況

88 for (Entry<E> e = header.next; e != header; e = e.next) {

89 if (e.element==null) {

90 remove(e);

91 return true;

92 }

93 }

94 } else {

95 // 若o不爲null的刪除狀況

96 for (Entry<E> e = header.next; e != header; e = e.next) {

97 if (o.equals(e.element)) {

98 remove(e);

99 return true;

100 }

101 }

102 }

103 return false;

104 }

105

106 // 將「集合(c)」添加到LinkedList中。

107 // 實際上，是從雙向鏈表的末尾開始，將「集合(c)」添加到雙向鏈表中。

108 public boolean addAll(Collection<?extends E> c) {

109 return addAll(size, c);

110 }

111

112 // 從雙向鏈表的index開始，將「集合(c)」添加到雙向鏈表中。

113 public boolean addAll(int index,Collection<? extends E> c) {

114 if (index < 0 || index > size)

115 throw newIndexOutOfBoundsException("Index: "+index+

116 ", Size: "+size);

117 Object[] a = c.toArray();

118 // 獲取集合的長度

119 int numNew = a.length;

120 if (numNew==0)

121 return false;

122 modCount++;

123

124 // 設置「當前要插入節點的後一個節點」

125 Entry<E> successor =(index==size ? header : entry(index));

126 // 設置「當前要插入節點的前一個節點」

127 Entry<E> predecessor =successor.previous;

128 // 將集合(c)所有插入雙向鏈表中

129 for (int i=0; i<numNew; i++) {

130 Entry<E> e = newEntry<E>((E)a[i], successor, predecessor);

131 predecessor.next = e;

132 predecessor = e;

133 }

134 successor.previous = predecessor;

135

136 // 調整LinkedList的實際大小

137 size += numNew;

138 return true;

139 }

140

141 // 清空雙向鏈表

142 public void clear() {

143 Entry<E> e = header.next;

144 // 從表頭開始，逐個向後遍歷；對遍歷到的節點執行一下操做：

145 // (01) 設置前一個節點爲null

146 // (02) 設置當前節點的內容爲null

147 // (03) 設置後一個節點爲「新的當前節點」

148 while (e != header) {

149 Entry<E> next = e.next;

150 e.next = e.previous = null;

151 e.element = null;

152 e = next;

153 }

154 header.next = header.previous =header;

155 // 設置大小爲0

156 size = 0;

157 modCount++;

158 }

159

160 // 返回LinkedList指定位置的元素

161 public E get(int index) {

162 return entry(index).element;

163 }

164

165 // 設置index位置對應的節點的值爲element

166 public E set(int index, E element) {

167 Entry<E> e = entry(index);

168 E oldVal = e.element;

169 e.element = element;

170 return oldVal;

171 }

172

173 // 在index前添加節點，且節點的值爲element

174 public void add(int index, E element) {

175 addBefore(element, (index==size ?header : entry(index)));

176 }

177

178 // 刪除index位置的節點

179 public E remove(int index) {

180 return remove(entry(index));

181 }

182

183 // 獲取雙向鏈表中指定位置的節點

184 private Entry<E> entry(int index) {

185 if (index < 0 || index >= size)

186 throw newIndexOutOfBoundsException("Index: "+index+

187 ", Size: "+size);

188 Entry<E> e = header;

189 // 獲取index處的節點。

190 // 若index < 雙向鏈表長度的1/2,則從前前後查找;

191 // 不然，從後向前查找。

192 if (index < (size >> 1)) {

193 for (int i = 0; i <= index;i++)

194 e = e.next;

195 } else {

196 for (int i = size; i > index;i--)

197 e = e.previous;

198 }

199 return e;

200 }

201

202 // 從前向後查找，返回「值爲對象(o)的節點對應的索引」

203 // 不存在就返回-1

204 public int indexOf(Object o) {

205 int index = 0;

206 if (o==null) {

207 for (Entry e = header.next; e !=header; e = e.next) {

208 if (e.element==null)

209 return index;

210 index++;

211 }

212 } else {

213 for (Entry e = header.next; e !=header; e = e.next) {

214 if (o.equals(e.element))

215 return index;

216 index++;

217 }

218 }

219 return -1;

220 }

221

222 // 從後向前查找，返回「值爲對象(o)的節點對應的索引」

223 // 不存在就返回-1

224 public int lastIndexOf(Object o) {

225 int index = size;

226 if (o==null) {

227 for (Entry e = header.previous; e!= header; e = e.previous) {

228 index--;

229 if (e.element==null)

230 return index;

231 }

232 } else {

233 for (Entry e = header.previous; e !=header; e = e.previous) {

234 index--;

235 if (o.equals(e.element))

236 return index;

237 }

238 }

239 return -1;

240 }

241

242 // 返回第一個節點

243 // 若LinkedList的大小爲0,則返回null

244 public E peek() {

245 if (size==0)

246 return null;

247 return getFirst();

248 }

249

250 // 返回第一個節點

251 // 若LinkedList的大小爲0,則拋出異常

252 public E element() {

253 return getFirst();

254 }

255

256 // 刪除並返回第一個節點

257 // 若LinkedList的大小爲0,則返回null

258 public E poll() {

259 if (size==0)

260 return null;

261 return removeFirst();

262 }

263

264 // 將e添加雙向鏈表末尾

265 public boolean offer(E e) {

266 return add(e);

267 }

268

269 // 將e添加雙向鏈表開頭

270 public boolean offerFirst(E e) {

271 addFirst(e);

272 return true;

273 }

274

275 // 將e添加雙向鏈表末尾

276 public boolean offerLast(E e) {

277 addLast(e);

278 return true;

279 }

280

281 // 返回第一個節點

282 // 若LinkedList的大小爲0,則返回null

283 public E peekFirst() {

284 if (size==0)

285 return null;

286 return getFirst();

287 }

288

289 // 返回最後一個節點

290 // 若LinkedList的大小爲0,則返回null

291 public E peekLast() {

292 if (size==0)

293 return null;

294 return getLast();

295 }

296

297 // 刪除並返回第一個節點

298 // 若LinkedList的大小爲0,則返回null

299 public E pollFirst() {

300 if (size==0)

301 return null;

302 return removeFirst();

303 }

304

305 // 刪除並返回最後一個節點

306 // 若LinkedList的大小爲0,則返回null

307 public E pollLast() {

308 if (size==0)

309 return null;

310 return removeLast();

311 }

312

313 // 將e插入到雙向鏈表開頭

314 public void push(E e) {

315 addFirst(e);

316 }

317

318 // 刪除並返回第一個節點

319 public E pop() {

320 return removeFirst();

321 }

322

323 // 從LinkedList開始向後查找，刪除第一個值爲元素(o)的節點

324 // 從鏈表開始查找，如存在節點的值爲元素(o)的節點，則刪除該節點

325 public booleanremoveFirstOccurrence(Object o) {

326 return remove(o);

327 }

328

329 // 從LinkedList末尾向前查找，刪除第一個值爲元素(o)的節點

330 // 從鏈表開始查找，如存在節點的值爲元素(o)的節點，則刪除該節點

331 public boolean removeLastOccurrence(Objecto) {

332 if (o==null) {

333 for (Entry<E> e =header.previous; e != header; e = e.previous) {

334 if (e.element==null) {

335 remove(e);

336 return true;

337 }

338 }

339 } else {

340 for (Entry<E> e =header.previous; e != header; e = e.previous) {

341 if (o.equals(e.element)) {

342 remove(e);

343 return true;

344 }

345 }

346 }

347 return false;

348 }

349

350 // 返回「index到末尾的所有節點」對應的ListIterator對象(List迭代器)

351 public ListIterator<E> listIterator(intindex) {

352 return new ListItr(index);

353 }

354

355 // List迭代器

356 private class ListItr implementsListIterator<E> {

357 // 上一次返回的節點

358 private Entry<E> lastReturned =header;

359 // 下一個節點

360 private Entry<E> next;

361 // 下一個節點對應的索引值

362 private int nextIndex;

363 // 指望的改變計數。用來實現fail-fast機制。

364 private int expectedModCount =modCount;

365

366 // 構造函數。

367 // 從index位置開始進行迭代

368 ListItr(int index) {

369 // index的有效性處理

370 if (index < 0 || index >size)

371 throw newIndexOutOfBoundsException("Index: "+index+ ", Size:"+size);

372 // 若「index 小於‘雙向鏈表長度的一半’」，則從第一個元素開始日後查找；

373 // 不然，從最後一個元素往前查找。

374 if (index < (size >> 1)){

375 next = header.next;

376 for (nextIndex=0;nextIndex<index; nextIndex++)

377 next = next.next;

378 } else {

379 next = header;

380 for (nextIndex=size;nextIndex>index; nextIndex--)

381 next = next.previous;

382 }

383 }

384

385 // 是否存在下一個元素

386 public boolean hasNext() {

387 // 經過元素索引是否等於「雙向鏈表大小」來判斷是否達到最後。

388 return nextIndex != size;

389 }

390

391 // 獲取下一個元素

392 public E next() {

393 checkForComodification();

394 if (nextIndex == size)

395 throw newNoSuchElementException();

396

397 lastReturned = next;

398 // next指向鏈表的下一個元素

399 next = next.next;

400 nextIndex++;

401 return lastReturned.element;

402 }

403

404 // 是否存在上一個元素

405 public boolean hasPrevious() {

406 // 經過元素索引是否等於0，來判斷是否達到開頭。

407 return nextIndex != 0;

408 }

409

410 // 獲取上一個元素

411 public E previous() {

412 if (nextIndex == 0)

413 throw newNoSuchElementException();

414

415 // next指向鏈表的上一個元素

416 lastReturned = next =next.previous;

417 nextIndex--;

418 checkForComodification();

419 return lastReturned.element;

420 }

421

422 // 獲取下一個元素的索引

423 public int nextIndex() {

424 return nextIndex;

425 }

426

427 // 獲取上一個元素的索引

428 public int previousIndex() {

429 return nextIndex-1;

430 }

431

432 // 刪除當前元素。

433 // 刪除雙向鏈表中的當前節點

434 public void remove() {

435 checkForComodification();

436 Entry<E> lastNext =lastReturned.next;

437 try {

438 LinkedList.this.remove(lastReturned);

439 } catch (NoSuchElementException e){

440 throw newIllegalStateException();

441 }

442 if (next==lastReturned)

443 next = lastNext;

444 else

445 nextIndex--;

446 lastReturned = header;

447 expectedModCount++;

448 }

449

450 // 設置當前節點爲e

451 public void set(E e) {

452 if (lastReturned == header)

453 throw newIllegalStateException();

454 checkForComodification();

455 lastReturned.element = e;

456 }

457

458 // 將e添加到當前節點的前面

459 public void add(E e) {

460 checkForComodification();

461 lastReturned = header;

462 addBefore(e, next);

463 nextIndex++;

464 expectedModCount++;

465 }

466

467 // 判斷「modCount和expectedModCount是否相等」，依次來實現fail-fast機制。

468 final void checkForComodification() {

469 if (modCount != expectedModCount)

470 throw newConcurrentModificationException();

471 }

472 }

473

474 // 雙向鏈表的節點所對應的數據結構。

475 // 包含3部分：上一節點，下一節點，當前節點值。

476 private static class Entry<E> {

477 // 當前節點所包含的值

478 E element;

479 // 下一個節點

480 Entry<E> next;

481 // 上一個節點

482 Entry<E> previous;

483

484 /**

485 * 鏈表節點的構造函數。

486 * 參數說明：

487 * element —— 節點所包含的數據

488 * next —— 下一個節點

489 * previous —— 上一個節點

490 */

491 Entry(E element, Entry<E> next,Entry<E> previous) {

492 this.element = element;

493 this.next = next;

494 this.previous = previous;

495 }

496 }

497

498 // 將節點(節點數據是e)添加到entry節點以前。

499 private Entry<E> addBefore(E e,Entry<E> entry) {

500 // 新建節點newEntry，將newEntry插入到節點e以前；而且設置newEntry的數據是e

501 Entry<E> newEntry = newEntry<E>(e, entry, entry.previous);

502 newEntry.previous.next = newEntry;

503 newEntry.next.previous = newEntry;

504 // 修改LinkedList大小

505 size++;

506 // 修改LinkedList的修改統計數：用來實現fail-fast機制。

507 modCount++;

508 return newEntry;

509 }

510

511 // 將節點從鏈表中刪除

512 private E remove(Entry<E> e) {

513 if (e == header)

514 throw newNoSuchElementException();

515

516 E result = e.element;

517 e.previous.next = e.next;

518 e.next.previous = e.previous;

519 e.next = e.previous = null;

520 e.element = null;

521 size--;

522 modCount++;

523 return result;

524 }

525

526 // 反向迭代器

527 public Iterator<E>descendingIterator() {

528 return new DescendingIterator();

529 }

530

531 // 反向迭代器實現類。

532 private class DescendingIteratorimplements Iterator {

533 final ListItr itr = newListItr(size());

534 // 反向迭代器是否下一個元素。

535 // 其實是判斷雙向鏈表的當前節點是否達到開頭

536 public boolean hasNext() {

537 return itr.hasPrevious();

538 }

539 // 反向迭代器獲取下一個元素。

540 // 其實是獲取雙向鏈表的前一個節點

541 public E next() {

542 return itr.previous();

543 }

544 // 刪除當前節點

545 public void remove() {

546 itr.remove();

547 }

548 }

549

550

551 // 返回LinkedList的Object[]數組

552 public Object[] toArray() {

553 // 新建Object[]數組

554 Object[] result = new Object[size];

555 int i = 0;

556 // 將鏈表中全部節點的數據都添加到Object[]數組中

557 for (Entry<E> e = header.next; e!= header; e = e.next)

558 result[i++] = e.element;

559 return result;

560 }

561

562 // 返回LinkedList的模板數組。所謂模板數組，便可以將T設爲任意的數據類型

563 public <T> T[] toArray(T[] a) {

564 // 若數組a的大小 < LinkedList的元素個數(意味着數組a不能容納LinkedList中所有元素)

565 // 則新建一個T[]數組，T[]的大小爲LinkedList大小，並將該T[]賦值給a。

566 if (a.length < size)

567 a =(T[])java.lang.reflect.Array.newInstance(

568 a.getClass().getComponentType(),size);

569 // 將鏈表中全部節點的數據都添加到數組a中

570 int i = 0;

571 Object[] result = a;

572 for (Entry<E> e = header.next; e!= header; e = e.next)

573 result[i++] = e.element;

574

575 if (a.length > size)

576 a[size] = null;

577

578 return a;

579 }

580

581

582 // 克隆函數。返回LinkedList的克隆對象。

583 public Object clone() {

584 LinkedList<E> clone = null;

585 // 克隆一個LinkedList克隆對象

586 try {

587 clone = (LinkedList<E>)super.clone();

588 } catch (CloneNotSupportedException e){

589 throw new InternalError();

590 }

591

592 // 新建LinkedList表頭節點

593 clone.header = new Entry<E>(null,null, null);

594 clone.header.next =clone.header.previous = clone.header;

595 clone.size = 0;

596 clone.modCount = 0;

597

598 // 將鏈表中全部節點的數據都添加到克隆對象中

599 for (Entry<E> e = header.next; e!= header; e = e.next)

600 clone.add(e.element);

601

602 return clone;

603 }

604

605 // java.io.Serializable的寫入函數

606 // 將LinkedList的「容量，全部的元素值」都寫入到輸出流中

607 private voidwriteObject(java.io.ObjectOutputStream s)

608 throws java.io.IOException {

609 // Write out any hidden serializationmagic

610 s.defaultWriteObject();

611

612 // 寫入「容量」

613 s.writeInt(size);

614

615 // 將鏈表中全部節點的數據都寫入到輸出流中

616 for (Entry e = header.next; e != header;e = e.next)

617 s.writeObject(e.element);

618 }

619

620 // java.io.Serializable的讀取函數：根據寫入方式反向讀出

621 // 先將LinkedList的「容量」讀出，而後將「全部的元素值」讀出

622 private voidreadObject(java.io.ObjectInputStream s)

623 throws java.io.IOException,ClassNotFoundException {

624 // Read in any hidden serializationmagic

625 s.defaultReadObject();

626

627 // 從輸入流中讀取「容量」

628 int size = s.readInt();

629

630 // 新建鏈表表頭節點

631 header = new Entry<E>(null,null, null);

632 header.next = header.previous =header;

633

634 // 從輸入流中將「全部的元素值」並逐個添加到鏈表中

635 for (int i=0; i<size; i++)

636 addBefore((E)s.readObject(),header);

637 }

638

639 }

複製代碼

總結：

(01) LinkedList 其實是經過雙向鏈表去實現的。

它包含一個很是重要的內部類：Entry。Entry是雙向鏈表節點所對應的數據結構，它包括的屬性有：當前節點所包含的值，上一個節點，下一個節點。

(02) 從LinkedList的實現方式中能夠發現，它不存在LinkedList容量不足的問題。

(03) LinkedList的克隆函數，便是將所有元素克隆到一個新的LinkedList對象中。

(04) LinkedList實現java.io.Serializable。當寫入到輸出流時，先寫入「容量」，再依次寫入「每個節點保護的值」；當讀出輸入流時，先讀取「容量」，再依次讀取「每個元素」。

(05) 因爲LinkedList實現了Deque，而Deque接口定義了在雙端隊列兩端訪問元素的方法。提供插入、移除和檢查元素的方法。每種方法都存在兩種形式：一種形式在操做失敗時拋出異常，另外一種形式返回一個特殊值（null 或 false，具體取決於操做）。

總結起來以下表格：

第一個元素（頭部）最後一個元素（尾部）

拋出異常特殊值拋出異常特殊值

插入 addFirst(e) offerFirst(e) addLast(e) offerLast(e)

移除 removeFirst() pollFirst() removeLast() pollLast()

檢查 getFirst() peekFirst() getLast() peekLast()

(06) LinkedList能夠做爲FIFO(先進先出)的隊列，做爲FIFO的隊列時，下表的方法等價：

複製代碼

隊列方法等效方法

add(e) addLast(e)

offer(e) offerLast(e)

remove() removeFirst()

poll() pollFirst()

element() getFirst()

peek() peekFirst()

複製代碼

(07) LinkedList能夠做爲LIFO(後進先出)的棧，做爲LIFO的棧時，下表的方法等價：

棧方法等效方法

push(e) addFirst(e)

pop() removeFirst()

peek() peekFirst()

不管如何，千萬不要經過隨機訪問去遍歷LinkedList！

三、Vector

相對於ArrayList來講，Vector線程是安全的，也就是說是同步的

建立了一個向量類的對象後，能夠往其中隨意地插入不一樣的類的對象，既不需顧及類型也不需預先選定向量的容量，並可方便地進行查找。對於預先不知或不肯預先定義數組大小，並需頻繁進行查找、插入和刪除工做的狀況，能夠考慮使用向量類。向量類提供了三種構造方法：

public vector()

public vector(intinitialcapacity,int capacityIncrement)

public vector(intinitialcapacity)

使用第一種方法，系統會自動對向量對象進行管理。若使用後兩種方法，則系統將根據參數initialcapacity設定向量對象的容量（即向量對象可存儲數據的大小），當真正存放的數據個數超過容量時，系統會擴充向量對象的儲存容量。

參數capacityIncrement給定了每次擴充的擴充值。當capacityIncrement爲0時，則每次擴充一倍。利用這個功能能夠優化存儲。在Vector類中提供了各類方法方便用戶使用：

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。