来看Java汇合源码分析：LinkedList源码分析

多谢指点，其实我对.net和ruby也不是很了解，对与java也只是刚起步的阶段，只是在学习中有了点想法就写出来了，现在俺本科还没毕业，所以对大型项目基本上也没有什么经验。
LinkedList简介
LinkedList是基于双向轮回链表（从源码中能够很简单看出）完成的，除能够当作链表来操纵外，它还能够当作栈、行列和双端行列来利用。
LinkedList一样长短线程平安的，只在单线程下合适利用。
LinkedList完成了Serializable接口，因而它撑持序列化，可以经由过程序列化传输，完成了Cloneable接口，能被克隆。
LinkedList源码分析
LinkedList的源码以下（到场了对照具体的正文）：

2. packagejava.util;
4. publicclassLinkedList<E>
5. extendsAbstractSequentialList<E>
6. implementsList<E>,Deque<E>,Cloneable,java.io.Serializable
7. {
8. //链表的表头，表头不包括任何数据。Entry是个链表类数据布局。
9. privatetransientEntry<E>header=newEntry<E>(null,null,null);
11. //LinkedList中元素个数
12. privatetransientintsize=0;
14. //默许机关函数：创立一个空的链表
15. publicLinkedList(){
16. header.next=header.previous=header;
17. }
19. //包括“汇合”的机关函数:创立一个包括“汇合”的LinkedList
20. //本栏目更多出色内容：http://www.bianceng.cn/Programming/Java/
21. publicLinkedList(Collection<?extendsE>c){
22. this();
23. addAll(c);
24. }
26. //猎取LinkedList的第一个元素
27. publicEgetFirst(){
28. if(size==0)
29. thrownewNoSuchElementException();
31. //链表的表头header中不包括数据。
32. //这里前往header所指下一个节点所包括的数据。
33. returnheader.next.element;
34. }
36. //猎取LinkedList的最初一个元素
37. publicEgetLast(){
38. if(size==0)
39. thrownewNoSuchElementException();
41. //因为LinkedList是双向链表；而表头header不包括数据。
42. //因此，这里前往表头header的前一个节点所包括的数据。
43. returnheader.previous.element;
44. }
46. //删除LinkedList的第一个元素
47. publicEremoveFirst(){
48. returnremove(header.next);
49. }
51. //删除LinkedList的最初一个元素
52. publicEremoveLast(){
53. returnremove(header.previous);
54. }
56. //将元素增加到LinkedList的肇端地位
57. publicvoidaddFirst(Ee){
58. addBefore(e,header.next);
59. }
61. //将元素增加到LinkedList的停止地位
62. publicvoidaddLast(Ee){
63. addBefore(e,header);
64. }
66. //判别LinkedList是不是包括元素(o)
67. publicbooleancontains(Objecto){
68. returnindexOf(o)!=-1;
69. }
71. //前往LinkedList的巨细
72. publicintsize(){
73. returnsize;
74. }
76. //将元素(E)增加到LinkedList中
77. publicbooleanadd(Ee){
78. //将节点(节点数据是e)增加到表头(header)之前。
79. //即，将节点增加到双向链表的末了。
80. addBefore(e,header);
81. returntrue;
82. }
84. //从LinkedList中删除元素(o)
85. //从链表入手下手查找，如存在元素(o)则删除该元素并前往true；
86. //不然，前往false。
87. publicbooleanremove(Objecto){
88. if(o==null){
89. //若o为null的删除情形
90. for(Entry<E>e=header.next;e!=header;e=e.next){
91. if(e.element==null){
92. remove(e);
93. returntrue;
94. }
95. }
96. }else{
97. //若o不为null的删除情形
98. for(Entry<E>e=header.next;e!=header;e=e.next){
99. if(o.equals(e.element)){
100. remove(e);
101. returntrue;
102. }
103. }
104. }
105. returnfalse;
106. }
108. //将“汇合(c)”增加到LinkedList中。
109. //实践上，是从双向链表的开端入手下手，将“汇合(c)”增加到双向链表中。
110. publicbooleanaddAll(Collection<?extendsE>c){
111. returnaddAll(size,c);
112. }
114. //从双向链表的index入手下手，将“汇合(c)”增加到双向链表中。
115. publicbooleanaddAll(intindex,Collection<?extendsE>c){
116. if(index<0||index>size)
117. thrownewIndexOutOfBoundsException("Index:"+index+
118. ",Size:"+size);
119. Object[]a=c.toArray();
120. //猎取汇合的长度
121. intnumNew=a.length;
122. if(numNew==0)
123. returnfalse;
124. modCount++;
126. //设置“以后要拔出节点的后一个节点”
127. Entry<E>successor=(index==size?header:entry(index));
128. //设置“以后要拔出节点的前一个节点”
129. Entry<E>predecessor=successor.previous;
130. //将汇合(c)全体拔出双向链表中
131. for(inti=0;i<numNew;i++){
132. Entry<E>e=newEntry<E>((E)a[i],successor,predecessor);
133. predecessor.next=e;
134. predecessor=e;
135. }
136. successor.previous=predecessor;
138. //调剂LinkedList的实践巨细
139. size+=numNew;
140. returntrue;
141. }
143. //清空双向链表
144. publicvoidclear(){
145. Entry<E>e=header.next;
146. //从表头入手下手，逐一向后遍历；对遍历到的节点实行一下操纵：
147. //(01)设置前一个节点为null
148. //(02)设置以后节点的内容为null
149. //(03)设置后一个节点为“新确当前节点”
150. while(e!=header){
151. Entry<E>next=e.next;
152. e.next=e.previous=null;
153. e.element=null;
154. e=next;
155. }
156. header.next=header.previous=header;
157. //设置巨细为0
158. size=0;
159. modCount++;
160. }
162. //前往LinkedList指定地位的元素
163. publicEget(intindex){
164. returnentry(index).element;
165. }
167. //设置index地位对应的节点的值为element
168. publicEset(intindex,Eelement){
169. Entry<E>e=entry(index);
170. EoldVal=e.element;
171. e.element=element;
172. returnoldVal;
173. }
175. //在index前增加节点，且节点的值为element
176. publicvoidadd(intindex,Eelement){
177. addBefore(element,(index==size?header:entry(index)));
178. }
180. //删除index地位的节点
181. publicEremove(intindex){
182. returnremove(entry(index));
183. }
185. //猎取双向链表中指定地位的节点
186. privateEntry<E>entry(intindex){
187. if(index<0||index>=size)
188. thrownewIndexOutOfBoundsException("Index:"+index+
189. ",Size:"+size);
190. Entry<E>e=header;
191. //猎取index处的节点。
192. //若index<双向链表长度的1/2,则夙昔前后查找;
193. //不然，从后向前查找。
194. if(index<(size>>1)){
195. for(inti=0;i<=index;i++)
196. e=e.next;
197. }else{
198. for(inti=size;i>index;i--)
199. e=e.previous;
200. }
201. returne;
202. }
204. //夙昔向后查找，前往“值为对象(o)的节点对应的索引”
205. //不存在就前往-1
206. publicintindexOf(Objecto){
207. intindex=0;
208. if(o==null){
209. for(Entrye=header.next;e!=header;e=e.next){
210. if(e.element==null)
211. returnindex;
212. index++;
213. }
214. }else{
215. for(Entrye=header.next;e!=header;e=e.next){
216. if(o.equals(e.element))
217. returnindex;
218. index++;
219. }
220. }
221. return-1;
222. }
224. //从后向前查找，前往“值为对象(o)的节点对应的索引”
225. //不存在就前往-1
226. publicintlastIndexOf(Objecto){
227. intindex=size;
228. if(o==null){
229. for(Entrye=header.previous;e!=header;e=e.previous){
230. index--;
231. if(e.element==null)
232. returnindex;
233. }
234. }else{
235. for(Entrye=header.previous;e!=header;e=e.previous){
236. index--;
237. if(o.equals(e.element))
238. returnindex;
239. }
240. }
241. return-1;
242. }
244. //前往第一个节点
245. //若LinkedList的巨细为0,则前往null
246. publicEpeek(){
247. if(size==0)
248. returnnull;
249. returngetFirst();
250. }
252. //前往第一个节点
253. //若LinkedList的巨细为0,则抛出非常
254. publicEelement(){
255. returngetFirst();
256. }
258. //删除并前往第一个节点
259. //若LinkedList的巨细为0,则前往null
260. publicEpoll(){
261. if(size==0)
262. returnnull;
263. returnremoveFirst();
264. }
266. //将e增加双向链表开端
267. publicbooleanoffer(Ee){
268. returnadd(e);
269. }
271. //将e增加双向链表开首
272. publicbooleanofferFirst(Ee){
273. addFirst(e);
274. returntrue;
275. }
277. //将e增加双向链表开端
278. publicbooleanofferLast(Ee){
279. addLast(e);
280. returntrue;
281. }
283. //前往第一个节点
284. //若LinkedList的巨细为0,则前往null
285. publicEpeekFirst(){
286. if(size==0)
287. returnnull;
288. returngetFirst();
289. }
291. //前往最初一个节点
292. //若LinkedList的巨细为0,则前往null
293. publicEpeekLast(){
294. if(size==0)
295. returnnull;
296. returngetLast();
297. }
299. //删除并前往第一个节点
300. //若LinkedList的巨细为0,则前往null
301. publicEpollFirst(){
302. if(size==0)
303. returnnull;
304. returnremoveFirst();
305. }
307. //删除并前往最初一个节点
308. //若LinkedList的巨细为0,则前往null
309. publicEpollLast(){
310. if(size==0)
311. returnnull;
312. returnremoveLast();
313. }
315. //将e拔出到双向链表开首
316. publicvoidpush(Ee){
317. addFirst(e);
318. }
320. //删除并前往第一个节点
321. publicEpop(){
322. returnremoveFirst();
323. }
325. //从LinkedList入手下手向后查找，删除第一个值为元素(o)的节点
326. //从链表入手下手查找，如存在节点的值为元素(o)的节点，则删除该节点
327. publicbooleanremoveFirstOccurrence(Objecto){
328. returnremove(o);
329. }
331. //从LinkedList开端向前查找，删除第一个值为元素(o)的节点
332. //从链表入手下手查找，如存在节点的值为元素(o)的节点，则删除该节点
333. publicbooleanremoveLastOccurrence(Objecto){
334. if(o==null){
335. for(Entry<E>e=header.previous;e!=header;e=e.previous){
336. if(e.element==null){
337. remove(e);
338. returntrue;
339. }
340. }
341. }else{
342. for(Entry<E>e=header.previous;e!=header;e=e.previous){
343. if(o.equals(e.element)){
344. remove(e);
345. returntrue;
346. }
347. }
348. }
349. returnfalse;
350. }
352. //前往“index到开端的全体节点”对应的ListIterator对象(List迭代器)
353. publicListIterator<E>listIterator(intindex){
354. returnnewListItr(index);
355. }
357. //List迭代器
358. privateclassListItrimplementsListIterator<E>{
359. //上一次前往的节点
360. privateEntry<E>lastReturned=header;
361. //下一个节点
362. privateEntry<E>next;
363. //下一个节点对应的索引值
364. privateintnextIndex;
365. //希冀的改动计数。用来完成fail-fast机制。
366. privateintexpectedModCount=modCount;
368. //机关函数。
369. //从index地位入手下手举行迭代
370. ListItr(intindex){
371. //index的无效性处置
372. if(index<0||index>size)
373. thrownewIndexOutOfBoundsException("Index:"+index+",Size:"+size);
374. //若“index小于‘双向链表长度的一半’”，则从第一个元素入手下手今后查找；
375. //不然，从最初一个元素往前查找。
376. if(index<(size>>1)){
377. next=header.next;
378. for(nextIndex=0;nextIndex<index;nextIndex++)
379. next=next.next;
380. }else{
381. next=header;
382. for(nextIndex=size;nextIndex>index;nextIndex--)
383. next=next.previous;
384. }
385. }
387. //是不是存鄙人一个元素
388. publicbooleanhasNext(){
389. //经由过程元素索引是不是即是“双向链表巨细”来判别是不是到达最初。
390. returnnextIndex!=size;
391. }
393. //猎取下一个元素
394. publicEnext(){
395. checkForComodification();
396. if(nextIndex==size)
397. thrownewNoSuchElementException();
399. lastReturned=next;
400. //next指向链表的下一个元素
401. next=next.next;
402. nextIndex++;
403. returnlastReturned.element;
404. }
406. //是不是存在上一个元素
407. publicbooleanhasPrevious(){
408. //经由过程元素索引是不是即是0，来判别是不是到达开首。
409. returnnextIndex!=0;
410. }
412. //猎取上一个元素
413. publicEprevious(){
414. if(nextIndex==0)
415. thrownewNoSuchElementException();
417. //next指向链表的上一个元素
418. lastReturned=next=next.previous;
419. nextIndex--;
420. checkForComodification();
421. returnlastReturned.element;
422. }
424. //猎取下一个元素的索引
425. publicintnextIndex(){
426. returnnextIndex;
427. }
429. //猎取上一个元素的索引
430. publicintpreviousIndex(){
431. returnnextIndex-1;
432. }
434. //删除以后元素。
435. //删除双向链表中确当前节点
436. publicvoidremove(){
437. checkForComodification();
438. Entry<E>lastNext=lastReturned.next;
439. try{
440. LinkedList.this.remove(lastReturned);
441. }catch(NoSuchElementExceptione){
442. thrownewIllegalStateException();
443. }
444. if(next==lastReturned)
445. next=lastNext;
446. else
447. nextIndex--;
448. lastReturned=header;
449. expectedModCount++;
450. }
452. //设置以后节点为e
453. publicvoidset(Ee){
454. if(lastReturned==header)
455. thrownewIllegalStateException();
456. checkForComodification();
457. lastReturned.element=e;
458. }
460. //将e增加到以后节点的后面
461. publicvoidadd(Ee){
462. checkForComodification();
463. lastReturned=header;
464. addBefore(e,next);
465. nextIndex++;
466. expectedModCount++;
467. }
469. //判别“modCount和expectedModCount是不是相称”，顺次来完成fail-fast机制。
470. finalvoidcheckForComodification(){
471. if(modCount!=expectedModCount)
472. thrownewConcurrentModificationException();
473. }
474. }
476. //双向链表的节点所对应的数据布局。
477. //包括3部分：上一节点，下一节点，以后节点值。
478. privatestaticclassEntry<E>{
479. //以后节点所包括的值
480. Eelement;
481. //下一个节点
482. Entry<E>next;
483. //上一个节点
484. Entry<E>previous;
486. /**
487. *链表节点的机关函数。
488. *参数申明：
489. *element——节点所包括的数据
490. *next——下一个节点
491. *previous——上一个节点
492. */
493. Entry(Eelement,Entry<E>next,Entry<E>previous){
494. this.element=element;
495. this.next=next;
496. this.previous=previous;
497. }
498. }
500. //将节点(节点数据是e)增加到entry节点之前。
501. privateEntry<E>addBefore(Ee,Entry<E>entry){
502. //新建节点newEntry，将newEntry拔出到节点e之前；而且设置newEntry的数据是e
503. Entry<E>newEntry=newEntry<E>(e,entry,entry.previous);
504. newEntry.previous.next=newEntry;
505. newEntry.next.previous=newEntry;
506. //修正LinkedList巨细
507. size++;
508. //修正LinkedList的修正统计数：用来完成fail-fast机制。
509. modCount++;
510. returnnewEntry;
511. }
513. //将节点从链表中删除
514. privateEremove(Entry<E>e){
515. if(e==header)
516. thrownewNoSuchElementException();
518. Eresult=e.element;
519. e.previous.next=e.next;
520. e.next.previous=e.previous;
521. e.next=e.previous=null;
522. e.element=null;
523. size--;
524. modCount++;
525. returnresult;
526. }
528. //反向迭代器
529. publicIterator<E>descendingIterator(){
530. returnnewDescendingIterator();
531. }
533. //反向迭代器完成类。
534. privateclassDescendingIteratorimplementsIterator{
535. finalListItritr=newListItr(size());
536. //反向迭代器是不是下一个元素。
537. //实践上是判别双向链表确当前节点是不是到达开首
538. publicbooleanhasNext(){
539. returnitr.hasPrevious();
540. }
541. //反向迭代器猎取下一个元素。
542. //实践上是猎取双向链表的前一个节点
543. publicEnext(){
544. returnitr.previous();
545. }
546. //删除以后节点
547. publicvoidremove(){
548. itr.remove();
549. }
550. }
553. //前往LinkedList的Object[]数组
554. publicObject[]toArray(){
555. //新建Object[]数组
556. Object[]result=newObject[size];
557. inti=0;
558. //将链表中一切节点的数据都增加到Object[]数组中
559. for(Entry<E>e=header.next;e!=header;e=e.next)
560. result[i++]=e.element;
561. returnresult;
562. }
564. //前往LinkedList的模板数组。所谓模板数组，便可以将T设为恣意的数据范例
565. public<T>T[]toArray(T[]a){
566. //若数组a的巨细<LinkedList的元素个数(意味着数组a不克不及包容LinkedList中全体元素)
567. //则新建一个T[]数组，T[]的巨细为LinkedList巨细，并将该T[]赋值给a。
568. if(a.length<size)
569. a=(T[])java.lang.reflect.Array.newInstance(
570. a.getClass().getComponentType(),size);
571. //将链表中一切节点的数据都增加到数组a中
572. inti=0;
573. Object[]result=a;
574. for(Entry<E>e=header.next;e!=header;e=e.next)
575. result[i++]=e.element;
577. if(a.length>size)
578. a[size]=null;
580. returna;
581. }
584. //克隆函数。前往LinkedList的克隆对象。
585. publicObjectclone(){
586. LinkedList<E>clone=null;
587. //克隆一个LinkedList克隆对象
588. try{
589. clone=(LinkedList<E>)super.clone();
590. }catch(CloneNotSupportedExceptione){
591. thrownewInternalError();
592. }
594. //新建LinkedList表头节点
595. clone.header=newEntry<E>(null,null,null);
596. clone.header.next=clone.header.previous=clone.header;
597. clone.size=0;
598. clone.modCount=0;
600. //将链表中一切节点的数据都增加到克隆对象中
601. for(Entry<E>e=header.next;e!=header;e=e.next)
602. clone.add(e.element);
604. returnclone;
605. }
607. //java.io.Serializable的写进函数
608. //将LinkedList的“容量，一切的元素值”都写进到输入流中
609. privatevoidwriteObject(java.io.ObjectOutputStreams)
610. throwsjava.io.IOException{
611. //Writeoutanyhiddenserializationmagic
612. s.defaultWriteObject();
614. //写进“容量”
615. s.writeInt(size);
617. //将链表中一切节点的数据都写进到输入流中
618. for(Entrye=header.next;e!=header;e=e.next)
619. s.writeObject(e.element);
620. }
622. //java.io.Serializable的读取函数：依据写进体例反向读出
623. //先将LinkedList的“容量”读出，然后将“一切的元素值”读出
624. privatevoidreadObject(java.io.ObjectInputStreams)
625. throwsjava.io.IOException,ClassNotFoundException{
626. //Readinanyhiddenserializationmagic
627. s.defaultReadObject();
629. //从输出流中读取“容量”
630. intsize=s.readInt();
632. //新建链表表头节点
633. header=newEntry<E>(null,null,null);
634. header.next=header.previous=header;
636. //从输出流中将“一切的元素值”并逐一增加到链表中
637. for(inti=0;i<size;i++)
638. addBefore((E)s.readObject(),header);
639. }
641. }

复制代码

几点总结

关于LinkedList的源码，给出几点对照主要的总结：
<p>
微软什么都提供了。你可以试想一下，如果你是新手，你是希望你点一下按钮程序就能运行那，还是想自己一点一点的组织结构，然后打包发部，调错再打包......

你一定会高兴地说，哈哈，原来成为Java高手就这么简单啊!记得Tomjava也曾碰到过一个项目经理，号称Java很简单，只要三个月就可以学会。

是一种将安全性(Security)列为第一优先考虑的语言

多重继承（以接口取代）等特性，增加了垃圾回收器功能用于回收不再被引用的对象所占据的内存空间，使得程序员不用再为内存管理而担忧。在 Java 1.5 版本中，Java 又引入了泛型编程（Generic Programming）、类型安全的枚举、不定长参数和自动装/拆箱等语言特性。

Java自面世后就非常流行，发展迅速，对C++语言形成了有力冲击。Java 技术具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于个人PC、数据中心、游戏控制台

是一种使网页(Web Page)产生生动活泼画面的语言

至于JDBC，就不用我多说了，你如果用java编过存取数据库的程序，就应该很熟悉。还有，如果你要用Java编发送电子邮件的程序，你就得看看Javamail 了。

科学超级计算机、移动电话和互联网，同时拥有全球最大的开发者专业社群。

Jive的资料在很多网站上都有，大家可以找来研究一下。相信你读完代码后，会有脱胎换骨的感觉。遗憾的是Jive从2.5以后就不再无条件的开放源代码，同时有licence限制。不过幸好还有中国一流的Java程序员关注它，外国人不开源了，中国人就不能开源吗？这里向大家推荐一个汉化的Jive版本—J道。Jive(J道版)是由中国Java界大名 鼎鼎的banq在Jive 2.1版本基础上改编而成, 全中文，增加了一些实用功能，如贴图，用户头像和用户资料查询等，而且有一个开发团队在不断升级。你可以访问banq的网站