java LinkedList分析(ZZ)

1. // ZZ From ：http://
2.     // hi.baidu.com/yifan_870829/blog/item/6595fb03e0c614e908fa93f0.html
3.          public class LinkedList<E> extends AbstractSequentialList<E>
4.             implements List<E>, Deque<E>, Cloneable, java.io.Serializable {
5.                  private transient Entry<E> header = new Entry<E>(null, null, null);
6.                  private transient int size = 0;
7.          }      // 可以看到，LinkedList继承了抽象的序列链表类，并实现了List、Queue、Cloneable、Serializable接口，使LinkedList可以像队列一样进行操作，同时可以克隆和串行化，使其能够保存到文件。
8.         // 值得我们注意的是，在这里面声明变量时，用到了transient关键词。那么他是什么意思啊？
9.         // transient 关键字表示在Serializable 的时候不保存该值。这两个变量在串行化时，不需要保存。
11.         // Entry类到底是如何实现的呢？
12.         private static class Entry<E> {
13.         E element;
14.         Entry<E> next;
15.         Entry<E> previous;
16.         Entry(E element, Entry<E> next, Entry<E> previous) {
17.              this.element = element;
18.              this.next = next;
19.              this.previous = previous;
20.         }
21.         }
22.         // 可以看到了，Entry里面声明了变量elment，next和previous，这就是我们在数据结构中知道的一个节点类声明。这是一个双向链表，不是吗？
23.         public LinkedList() {
24.                 header.next = header.previous = header;
25.             }
26.         // 构造函数。初始化链表类。将next和previous指针指向自己。
27.         public LinkedList(Collection<? extends E> c) {
28.             this();
29.             addAll(c);
30.         }
31.         // 用一个链表类初始化LinkedList，关于上面的红色部分，据我的理解，这个泛型类要求加入的泛型元素必须是E的子类。
32.         // 这个构造函数调用了默认构造函数，addAll把c添加到LinkedList中，下面会介绍这个函数。
33.         public E getFirst() {
34.                if (size==0) {
35.                    throw new NoSuchElementException();
36.                }
37.             return header.next.element;
38.         }
39.         // 返回第一个元素。如果size==0，抛出异常，否则就返回head.next.element；
40.         // 通过这句话，我们似乎明白，这里的数据结构是有头结点的。
41.         public E getLast() {
42.              if (size==0) {
43.                  throw new NoSuchElementException();
44.              }
45.              return header.previous.element;
46.         }
47.         // 返回最后一个元素。如果size==0，那么抛出异常。否则返回header.previous.element。
48.         // 这就是双向链表，将头结点的previous指向最后一个元素。
49.         public E removeFirst() {
50.             return remove(header.next);
51.         }
52.         
53.         public E removeLast() {
54.            return remove(header.previous);
55.         }
56.         
57.         public E remove(int index) {
58.                 return remove(entry(index));
59.         }
60.         
61.         private E remove(Entry<E> e) {
62.             if (e == header) {
63.                 throw new NoSuchElementException();
64.             }
65.             E result = e.element;
66.             e.previous.next = e.next;
67.             e.next.previous = e.previous;
68.             e.next = e.previous = null;
69.             e.element = null;
70.             size--;
71.             modCount++;
72.             return result;
73.         }
74.         // 移走元素。要移走的元素已经确定，不需再找到这个元素。所以直接移走就可以了。先用result指向要移走的元素。然后按照数据结构中的算法移走就可以了。移走后返回移走的元素。
75.         // modCount是在AbstractList中声明使用的。用来记录这个链表结构被修改的次数。this list has been
76.         
77.         public void addFirst(E e) {
78.             addBefore(e, header.next);
79.         }
80.         
81.         public void addLast(E e) {
82.             addBefore(e, header);
83.         }
84.         
85.         public boolean add(E e) {
86.             addBefore(e, header);
87.                 return true;
88.         }
89.         
90.         public void add(int index, E element) {
91.             addBefore(element, (index==size ? header : entry(index)));
92.         }
93.         
94.         private Entry<E> addBefore(E e, Entry<E> entry) {
95.             Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);
96.             newEntry.previous.next = newEntry;
97.             newEntry.next.previous = newEntry;
98.             size++;
99.             modCount++;
100.             return newEntry;
101.         }
102.         // 将元素e添加到entry前面。很简单，不用分析，相信你也明白。
103.         
104.         public boolean contains(Object o) {
105.             return indexOf(o) != -1;
106.         }
107.         public int indexOf(Object o) {
108.                 int index = 0;
109.                 if (o==null) {// 如果o为null
110.                     for (Entry e = header.next; e != header; e = e.next) {
111.                         if (e.element==null)
112.                             return index;
113.                         index++;
114.                     }
115.                 } else {        //不为空，其判断是通过equals进行判断的。
116.                     for (Entry e = header.next; e != header; e = e.next) {
117.                         if (o.equals(e.element))
118.                             return index;
119.                         index++;
120.                     }
121.                 }
122.                 return -1;
123.             }
124.         // 首先获得元素的索引值。如果返回-1，无这个元素。为什么要分元素是不是空这个分支呢？因为如果o是空的话，判断是通过e.element==null判断的。不为空，则通过o.equals(e.element)判断。
125.         public int size() {
126.         return size;
127.             }
128.         // 返回大小。
129.         public boolean remove(Object o) {
130.                 if (o==null) {
131.                     for (Entry<E> e = header.next; e != header; e = e.next) {
132.                         if (e.element==null) {
133.                             remove(e);
134.                             return true;
135.                         }
136.                     }
137.                 } else {
138.                     for (Entry<E> e = header.next; e != header; e = e.next) {
139.                         if (o.equals(e.element)) {
140.                             remove(e);
141.                             return true;
142.                         }
143.                     }
144.                 }
145.                 return false;
146.             }
147.         // 也比较容易理解。不做解释了。
148.         
149.         public boolean addAll(Collection<? extends E> c) {
150.             return addAll(size, c);
151.         }
152.         
153.         public boolean addAll(int index, Collection<? extends E> c) {
154.                 if (index < 0 || index > size)// 如果要插入的位置>size或小于0，异常。
155.                     throw new IndexOutOfBoundsException("Index: "+index+
156.                                                         ", Size: "+size);
157.                 Object[] a = c.toArray();// 将集合中的元素转化为数组。
158.                 int numNew = a.length;// 返回数组长度
159.                 if (numNew==0)// 如果是0的话，遗憾，无法添加了
160.                     return false;
161.                 modCount++;// 不是0的话，ok，修改计数器加1
162.                 Entry<E> successor = (index==size ? header : entry(index));// 如果index==size，那么successor=header
163.                 Entry<E> predecessor = successor.previous;// 获得前一个处理元素
164.             for (int i=0; i<numNew; i++) {// 对于数组每一个元素，生成entry类，加入到链表中。
165.                         Entry<E> e = new Entry<E>((E)a[i], successor, predecessor);
166.                         predecessor.next = e;
167.                         predecessor = e;
168.                     }
169.                 successor.previous = predecessor;
170.                 size += numNew;
171.                 return true;
172.          }
173.         // 如上注解。
174.         
175.         public void clear() {
176.                 Entry<E> e = header.next;
177.                 while (e != header) {
178.                     Entry<E> next = e.next;// 记录e的next
179.                     e.next = e.previous = null;// 去掉e的next和previous
180.                     e.element = null;// 去掉自己元素。
181.                     e = next;// 处理下一个节点
182.                 }
183.                 header.next = header.previous = header;
184.                 size = 0;
185.                 modCount++;
186.         }
187.         // 将链表清空。不用解释了。很简单。不过，我们通过这个方法明白一点，要真正的销毁对象，光靠垃圾回收机制是不行的。像这里，给没有用的引用赋空值，使内存中的实体对象没有指针，而加快内存的回收。
188.         public E get(int index) {
189.             return entry(index).element;
190.         }
191.         
192.         private Entry<E> entry(int index) {
193.                 if (index < 0 || index >= size)
194.                     throw new IndexOutOfBoundsException("Index: "+index+
195.                                                         ", Size: "+size);
196.                 Entry<E> e = header;// 获得头结点
197.                 if (index < (size >> 1)) {// 如果index小于size的一半
198.                     for (int i = 0; i <= index; i++)
199.                         e = e.next;
200.                 } else {// 不小于的话，ok，从后面找。
201.                     for (int i = size; i > index; i--)
202.                         e = e.previous;
203.                 }
204.                 return e;
205.             }
206.         
207.         // 多么好的算法啊。如果要找的元素在前半部分，那就从头找，如果在最后那么就从尾开始找。获得size的一半也很节省cpu消耗，采用移位的方式，值得学习。
208.         public E set(int index, E element) {
209.                 Entry<E> e = entry(index);
210.                 E oldVal = e.element;
211.                 e.element = element;
212.                 return oldVal;
213.             }
214.         // 不再解释。很简单。
215.         
216.         // 下面的分析关系到了LinkedList的遍历、持久化、克隆等相关主题。
217.         public ListIterator<E> listIterator(int index) {
218.             return new ListItr(index);
219.         }
220.         // 返回一个从index开始的遍历器。
221.   private class ListItr implements ListIterator<E> {
222.         private Entry<E> lastReturned = header;// 让这里面的参数初始化，最后一个返回的元素。
223.         private Entry<E> next;// 下一个元素的指针
224.         private int nextIndex;// 下一个元素的索引
225.         private int expectedModCount = modCount;// 等于原来类中的修改次数
226.         
227.         ListItr(int index) {// 构造函数
228.              if (index < 0 || index > size)// 如果给的index不正确
229.            throw new IndexOutOfBoundsException("Index: "+index+
230.                   ", Size: "+size);
231.              if (index < (size >> 1)) {// 如果index<size的一半
232.                    next = header.next;// 找到index所指的元素
233.                    for (nextIndex=0; nextIndex<index; nextIndex++)
234.                       next = next.next;
235.              } else {
236.                    next = header;// 从后面遍历，找到所要的元素
237.                    for (nextIndex=size; nextIndex>index; nextIndex--)
238.                       next = next.previous;
239.              }
240.         }
241.         
242.         public boolean hasNext() {// 判断有没有下个元素
243.              return nextIndex != size;
244.         }
245.         
246.         public E next() {获得下一个元素
247.              checkForComodification();
248.              if (nextIndex == size)
249.                  throw new NoSuchElementException();
250.              lastReturned = next;
251.              next = next.next;
252.              nextIndex++;
253.              return lastReturned.element;
254.         }
255.         
256.         public boolean hasPrevious() {
257.              return nextIndex != 0;
258.         }
259.         
260.         public E previous() {
261.              if (nextIndex == 0)
262.                  throw new NoSuchElementException();
263.              lastReturned = next = next.previous;
264.              nextIndex--;
265.              checkForComodification();
266.              return lastReturned.element;
267.         }
268.         
269.         public int nextIndex() {
270.              return nextIndex;
271.         }
272.         
273.         public int previousIndex() {
274.              return nextIndex-1;
275.         }
276.         
277.         public void remove() {
278.                 checkForComodification();
279.                 Entry<E> lastNext = lastReturned.next;
280.                 try {
281.                     LinkedList.this.remove(lastReturned);
282.                 } catch (NoSuchElementException e) {
283.                     throw new IllegalStateException();
284.                 }
285.                 if (next==lastReturned)
286.                         next = lastNext;
287.                     else
288.                 nextIndex--;
289.                 lastReturned = header;
290.                 expectedModCount++;
291.         }
292.         
293.         public void set(E e) {
294.              if (lastReturned == header)
295.                  throw new IllegalStateException();
296.              checkForComodification();
297.              lastReturned.element = e;
298.         }
299.         
300.         public void add(E e) {
301.              checkForComodification();
302.              lastReturned = header;
303.              addBefore(e, next);
304.              nextIndex++;
305.              expectedModCount++;
306.         }
307.         
308.         final void checkForComodification() {//
309.              if (modCount != expectedModCount)
310.                  throw new ConcurrentModificationException();
311.         }
312.    }
313.         //上面的这个类是定义在LinkedList中的私有类。他实现了ListIterator具体的分析参照上面的注释。
314.         public Iterator<E> descendingIterator() {
315.              return new DescendingIterator();
316.         }
317.         private class DescendingIterator implements Iterator {
318.                 final ListItr itr = new ListItr(size());
319.                 public boolean hasNext() {
320.                      return itr.hasPrevious();
321.                 }
322.                 public E next() {
323.                      return itr.previous();
324.                 }
325.                 public void remove() {
326.                     itr.remove();
327.                 }
328.         }
329.         //上面的函数和类仍然返回不同的遍历器。不再解释。
330.         //不过DescendingIterator 是递减的遍历器。可以注意到他的next()、hasNext()方法的不同。
331.         public Object clone() {
332.                 LinkedList<E> clone = null;
333.                 try {
334.                      clone = (LinkedList<E>) super.clone();// 先调用父类的克隆函数
335.                 } catch (CloneNotSupportedException e) {
336.                      throw new InternalError();
337.                 }
338.                 // Put clone into "virgin" state
339.                 clone.header = new Entry<E>(null, null, null);// 自己开始复制，先复制头节点
340.                 clone.header.next = clone.header.previous = clone.header;// 给头结点赋值
341.                 clone.size = 0;
342.                 clone.modCount = 0;
343.                 // Initialize clone with our elements
344.                 for (Entry<E> e = header.next; e != header; e = e.next)// 把元素也复制过去
345.                     clone.add(e.element);
346.                 return clone;
347.          }
348.         
349.         public Object[] toArray() {
350.                 Object[] result = new Object[size];
351.                 int i = 0;
352.                 for (Entry<E> e = header.next; e != header; e = e.next)
353.                     result[i++] = e.element;
354.                 return result;
355.         }
356.         // 转化成数组。
357.         public <T> T[] toArray(T[] a) {
358.                 
359.                 // 如果a太小了，那么就在重新给a分配空间吧。
360.                 if (a.length < size)
361.                     a = (T[])java.lang.reflect.Array.newInstance(
362.                                         a.getClass().getComponentType(), size);// 如何分配，那么就用反射机制吧。
363.                 
364.                 // 有地方放了，好吧数据放入数组中，呵呵。
365.                 int i = 0;
366.                 Object[] result = a;
367.                 for (Entry<E> e = header.next; e != header; e = e.next)
368.                     result[i++] = e.element;
369.                 if (a.length > size)  // 如果a长了，a【size】=null，使不能访问后面的元素。
370.                     a[size] = null;
371.                 return a;
372.             }
373.         private static final long serialVersionUID = 876323262645176354L;
374.            private void writeObject(java.io.ObjectOutputStream s)
375.                 throws java.io.IOException {
376.                // Write out any hidden serialization magic
377.                s.defaultWriteObject();
378.                 // Write out size
379.                 s.writeInt(size);
380.                 // Write out all elements in the proper order.
381.                 for (Entry e = header.next; e != header; e = e.next)
382.                     s.writeObject(e.element);
383.             }
384.            
385.         private void readObject(java.io.ObjectInputStream s)
386.                 throws java.io.IOException, ClassNotFoundException {
387.                 // Read in any hidden serialization magic
388.                 s.defaultReadObject();
389.                 // Read in size
390.                 int size = s.readInt();
391.                 // Initialize header
392.                 header = new Entry<E>(null, null, null);
393.                 header.next = header.previous = header;
394.                 // Read in all elements in the proper order.
395.                 for (int i=0; i<size; i++)
396.                     addBefore((E)s.readObject(), header);
397.             }
398.         }
399.         // 不再说明，很容易理解。就是先写入size，再写入每一个数据，读出也一样，先读取size，再读取对象。