一、LinkedList简介
LinkedList是一种可以在任何位置进行高效地插入和移除操作的有序序列，它是基于双向链表实现的。
ps:这里有一个问题，就是关于实现LinkedList的数据结构是否为循环的双向链表，上网搜了有很多文章都说是循环的，并且有的文章中但是我看了源代码觉得应该不是循环的？
例如在删除列表尾部节点的代码：
private E unlinkLast(Node<E> l)
{ final E element = l.item; final Node<E> prev = l.prev; l.item = null; l.prev = null; // help GC last = prev; if (prev == null) first = null; else prev.next = null; size--; modCount++; return element; }
这里删除尾节点l后，将l前面的节点prev的next置为null，而并没有指向head节点。不知道是不是因为代码版本的原因(我的源代码是在下载的jdk1.8.0_45文件中获取的)，如果读者看到知道原因，希望能够帮忙解答！
在源码中定义了节点的基本结构：
private static class Node<E> { E item; //表示该节点包含的值 Node<E> next; //表达当前节点的下一个节点 Node<E> prev; //表示当前节点的上一个节点 Node(Node<E> prev, E element, Node<E> next) { this.item = element; this.next = next; this.prev = prev; } }
LinkedList的类图如下所示：
LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。
LinkedList 实现 List 接口，能对它进行队列操作。
LinkedList 实现 Deque 接口，即能将LinkedList当作双端队列使用。
LinkedList 实现了Cloneable接口，即覆盖了函数clone()，能克隆。
LinkedList 实现java.io.Serializable接口，这意味着LinkedList支持序列化，能通过序列化去传输。
LinkedList 是非同步的。
二、LinkedList源码分析
1 public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, java.io.Serializable 2 { 3 //实现Serilizable接口时，将不需要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会序列化到指定的目的地中。 4 transient int size = 0; 5 //指向首节点 6 transient Node<E> first; 7 //指向最后一个节点 8 transient Node<E> last; 9 //构建一个空列表 10 public LinkedList() { 11 } 12 //构建一个包含集合c的列表 13 public LinkedList(Collection<? extends E> c) { 14 this(); 15 addAll(c); 16 } 17 //将节点值为e的节点作为首节点 18 private void linkFirst(E e) { 19 final Node<E> f = first; 20 //构建一个prev值为null,next为f,节点值为e的节点 21 final Node<E> newNode = new Node<>(null, e, f); 22 //将newNode作为首节点 23 first = newNode; 24 //如果newNode后面没有节点就将newNode作为最后一个节点 25 if (f == null) 26 last = newNode; 27 //否则就将newNode赋给其prev 28 else 29 f.prev = newNode; 30 //列表长度加一 31 size++; 32 modCount++; 33 } 34 //将节点值为e的节点作为最后一个节点 35 void linkLast(E e) { 36 final Node<E> l = last; 37 //构建一个prev值为l,next为null,节点值为e的节点 38 final Node<E> newNode = new Node<>(l, e, null); 39 last = newNode; 40 if (l == null) 41 first = newNode; 42 else 43 l.next = newNode; 44 size++; 45 modCount++; 46 } 47 //在非空节点succ之前插入节点e 48 void linkBefore(E e, Node<E> succ) { 49 final Node<E> pred = succ.prev; 50 //将succ前面的节点和succ作为其prev和next 51 final Node<E> newNode = new Node<>(pred, e, succ); 52 //然后将newNode作为succ的prev 53 succ.prev = newNode; 54 //如果原来succ是首节点，则将newNode设置为首节点 55 if (pred == null) 56 first = newNode; 57 else 58 pred.next = newNode; 59 size++; 60 modCount++; 61 } 62 //释放非空的首节点f 63 private E unlinkFirst(Node<E> f) { 64 final E element = f.item; 65 final Node<E> next = f.next; 66 f.item = null; 67 f.next = null; // help GC 68 //将first节点后面的节点设为首节点 69 first = next; 70 if (next == null) 71 last = null; 72 else 73 next.prev = null; 74 size--; 75 modCount++; 76 return element; 77 } 78 //释放非空的尾节点l 79 private E unlinkLast(Node<E> l) { 80 final E element = l.item; 81 final Node<E> prev = l.prev; 82 l.item = null; 83 l.prev = null; // help GC 84 last = prev; 85 if (prev == null) 86 first = null; 87 else 88 prev.next = null; 89 size--; 90 modCount++; 91 return element; 92 } 93 //删除非空节点x 94 E unlink(Node<E> x) 95 { 96 final E element = x.item; 97 final Node<E> next = x.next; //x后面的节点 98 final Node<E> prev = x.prev; //x前面的节点 99 100 if (prev == null) { 101 first = next; 102 } else { 103 prev.next = next; 104 x.prev = null; 105 } 106 if (next == null) { 107 last = prev; 108 } else { 109 next.prev = prev; 110 x.next = null; 111 } 112 x.item = null; 113 size--; 114 modCount++; 115 return element; 116 } 117 //返回列表首节点元素值 118 public E getFirst() { 119 final Node<E> f = first; 120 if (f == null) 121 throw new NoSuchElementException(); 122 return f.item; 123 } 124 //返列表尾节点元素值 125 public E getLast() { 126 final Node<E> l = last; 127 if (l == null) 128 throw new NoSuchElementException(); 129 return l.item; 130 } 131 //移除首节点 132 public E removeFirst() { 133 final Node<E> f = first; 134 if (f == null) 135 throw new NoSuchElementException(); 136 return unlinkFirst(f); 137 } 138 //删除尾节点 139 public E removeLast() { 140 final Node<E> l = last; 141 if (l == null) 142 throw new NoSuchElementException(); 143 return unlinkLast(l); 144 } 145 //在列表首部插入节点e 146 public void addFirst(E e) { 147 linkFirst(e); 148 } 149 //在列表尾部插入节点e 150 public void addLast(E e) { 151 linkLast(e); 152 } 153 //判断列表中是否包含有元素o 154 public boolean contains(Object o) { 155 return indexOf(o) != -1; 156 } 157 //返回列表长度大小 158 public int size() { 159 return size; 160 } 161 //在列表尾部插入元素 162 public boolean add(E e) { 163 linkLast(e); 164 return true; 165 } 166 //删除元素为o的节点 167 public boolean remove(Object o) 168 { 169 if (o == null) { 170 for (Node<E> x = first; x != null; x = x.next) { 171 if (x.item == null) { 172 unlink(x); 173 return true; 174 } 175 } 176 } else { 177 for (Node<E> x = first; x != null; x = x.next) { 178 if (o.equals(x.item)) { 179 unlink(x); 180 return true; 181 } 182 } 183 } 184 return false; 185 } 186 //将集合c中所有元素添加到列表的尾部 187 public boolean addAll(Collection<? extends E> c) { 188 return addAll(size, c); 189 } 190 //从指定的位置index开始，将集合c中的元素插入到列表中 191 public boolean addAll(int index, Collection<? extends E> c) { 192 //首先判断插入位置的合法性 193 checkPositionIndex(index); 194 Object[] a = c.toArray(); 195 int numNew = a.length; 196 if (numNew == 0) 197 return false; 198 Node<E> pred, succ; 199 if (index == size) {//说明在列表尾部插入集合元素 200 succ = null; 201 pred = last; 202 } 203 else { //否则，找到index所在的节点 204 succ = node(index); 205 pred = succ.prev; 206 } 207 for (Object o : a) { 208 @SuppressWarnings("unchecked") E e = (E) o; 209 Node<E> newNode = new Node<>(pred, e, null); 210 if (pred == null) 211 first = newNode; 212 else 213 pred.next = newNode; 214 pred = newNode; 215 } 216 if (succ == null) { 217 last = pred; 218 } else { 219 pred.next = succ; 220 succ.prev = pred; 221 } 222 size += numNew; 223 modCount++; 224 return true; 225 } 226 //删除列表中所有节点 227 public void clear() { 228 for (Node<E> x = first; x != null; ) 229 { 230 Node<E> next = x.next; 231 x.item = null; 232 x.next = null; 233 x.prev = null; 234 x = next; 235 } 236 first = last = null; 237 size = 0; 238 modCount++; 239 } 240 //获取指定索引位置节点的元素值 241 public E get(int index) { 242 checkElementIndex(index); 243 return node(index).item; 244 } 245 //替换指定索引位置节点的元素值 246 public E set(int index, E element) { 247 checkElementIndex(index); 248 Node<E> x = node(index); 249 E oldVal = x.item; 250 x.item = element; 251 return oldVal; 252 } 253 //在指定索引位置之前插入元素e 254 public void add(int index, E element) { 255 checkPositionIndex(index); 256 if (index == size) 257 linkLast(element); 258 else 259 linkBefore(element, node(index)); 260 } 261 //删除指定位置的元素 262 public E remove(int index) { 263 checkElementIndex(index); 264 return unlink(node(index)); 265 } 266 //判断指定索引位置的元素是否存在 267 private boolean isElementIndex(int index) { 268 return index >= 0 && index < size; 269 } 270 private boolean isPositionIndex(int index) { 271 return index >= 0 && index <= size; 272 } 273 //构建 IndexOutOfBoundsException详细信息 274 private String outOfBoundsMsg(int index) { 275 return "Index: "+index+", Size: "+size; 276 } 277 private void checkElementIndex(int index) { 278 if (!isElementIndex(index)) 279 throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); 280 } 281 private void checkPositionIndex(int index) { 282 if (!isPositionIndex(index)) 283 throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); 284 } 285 //返回指定索引位置的节点 286 Node<E> node(int index) { 287 //此处是一个小技巧，当index<size/2时，从列表前半部分开始，否则从后半部分开始 288 if (index < (size >> 1)) { 289 Node<E> x = first; 290 for (int i = 0; i < index; i++) 291 x = x.next; 292 return x; 293 } else { 294 Node<E> x = last; 295 for (int i = size - 1; i > index; i--) 296 x = x.prev; 297 return x; 298 } 299 }//返回列表中第一次出现o的位置，若不存在则返回-1 300 public int indexOf(Object o) { 301 int index = 0; 302 if (o == null) { 303 for (Node<E> x = first; x != null; x = x.next) { 304 if (x.item == null) 305 return index; 306 index++; 307 } 308 } else { 309 for (Node<E> x = first; x != null; x = x.next) { 310 if (o.equals(x.item)) 311 return index; 312 index++; 313 } 314 } 315 return -1; 316 } 317 //逆向搜索，返回第一出现o的位置，不存在则返回-1 318 public int lastIndexOf(Object o) { 319 int index = size; 320 if (o == null) { 321 for (Node<E> x = last; x != null; x = x.prev) { 322 index--; 323 if (x.item == null) 324 return index; 325 } 326 } else { 327 for (Node<E> x = last; x != null; x = x.prev) { 328 index--; 329 if (o.equals(x.item)) 330 return index; 331 } 332 } 333 return -1; 334 } 335 //获取列表首节点元素值 336 public E peek() { 337 final Node<E> f = first; 338 return (f == null) ? null : f.item; 339 } 340 341 //获取列表首节点元素值，若为空则抛异常 342 public E element() { 343 return getFirst(); 344 } 345 //检索首节点，若空则返回null,不为空则返回其元素值并删除首节点 346 public E poll() { 347 final Node<E> f = first; 348 return (f == null) ? null : unlinkFirst(f); 349 } 350 //检索首节点，若空则抛异常,不为空则返回其元素值并删除首节点 351 public E remove() { 352 return removeFirst(); 353 } 354 //在列表尾部增加节点e 355 public boolean offer(E e) { 356 return add(e); 357 } 358 //在列表首部插入节点e 359 public boolean offerFirst(E e) { 360 addFirst(e); 361 return true; 362 } 363 //在列表尾部插入节点e 364 public boolean offerLast(E e) { 365 addLast(e); 366 return true; 367 } 368 public E peekFirst() { 369 final Node<E> f = first; 370 return (f == null) ? null : f.item; 371 } 372 //获取列表尾节点元素值 373 public E peekLast() { 374 final Node<E> l = last; 375 return (l == null) ? null : l.item; 376 } 377 public E pollFirst() { 378 final Node<E> f = first; 379 return (f == null) ? null : unlinkFirst(f); 380 } 381 public E pollLast() { 382 final Node<E> l = last; 383 return (l == null) ? null : unlinkLast(l); 384 } 385 //入栈 386 public void push(E e) 387 { 388 addFirst(e); 389 } 390 //出栈 391 public E pop() { 392 return removeFirst(); 393 } 394 //删除列表中第一出现o的节点 395 public boolean removeFirstOccurrence(Object o) { 396 return remove(o); 397 } 398 //逆向搜索，删除第一次出现o的节点 399 public boolean removeLastOccurrence(Object o) { 400 if (o == null) { 401 for (Node<E> x = last; x != null; x = x.prev) { 402 if (x.item == null) { 403 unlink(x); 404 return true; 405 } 406 } 407 } else { 408 for (Node<E> x = last; x != null; x = x.prev) { 409 if (o.equals(x.item)) { 410 unlink(x); 411 return true; 412 } 413 } 414 } 415 return false; 416 }
三、关于LinkedList的几点说明
1、注意源码中的 Node<E> node(int index)方法：
Node<E> node(int 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; } }
该方法返回双向链表中指定位置处的节点，而链表中是没有下标索引的，要指定位置出的元素，就要遍历该链表，从源码的实现中，我们看到这里有一个加速动作。源码中先将index与长度size的一半比较，如果index<size/2，就只从位置0往后遍历到位置index处，而如果index>size/2，就只从位置size往前遍历到位置index处。这样可以减少一部分不必要的遍历。
2、LinkedList与ArrayList的区别：
LinkedList与ArrayList在性能上各有优缺点，都有各自适用的地方，总结如下：
- ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
- LinkedList不支持高效的随机元素访问。
- ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间，就存储密度来说，ArrayList是优于LinkedList的。
总之，当操作是在一列数据的后面添加数据而不是在前面或中间,并且需要随机地访问其中的元素时,使用ArrayList会提供比较好的性能，当你的操作是在一列数据的前面或中间添加或删除数据,并且按照顺序访问其中的元素时,就应该使用LinkedList了。
3、LinkedList中允许元素为null
在查找和删除时，源代码如下所示：
public int indexOf(Object o) { int index = 0; if (o == null) { for (Node<E> x = first; x != null; x = x.next) { if (x.item == null) return index; index++; } } else { for (Node<E> x = first; x != null; x = x.next) { if (o.equals(x.item)) return index; index++; } } return -1; }
4、利用LinkedList实现栈操作
public class Stack<T> { private LinkedList<T> stack; //无参构造函数 public Stack() { stack=new LinkedList<T>(); } //构造一个包含指定collection中所有元素的栈 public Stack(Collection<? extends T> c) { stack=new LinkedList<T>(c); } //入栈 public void push(T t) { stack.addFirst(t); } //出栈 public T pull() { return stack.remove(); } //栈是否为空 boolean isEmpty() { return stack.isEmpty(); } //打印栈元素 public void display() { for(Object o:stack) System.out.println(o); } }
5、LinkedList的基本用法：
推荐一篇介绍LinkedList基本用法的博文http://blog.csdn.net/i_lovefish/article/details/8042883，这里不再赘述。
