LinkedList源码解析

package java.util;

//linkedlist是双向链表，结构看起来是一个环，最后一个数据接到header上
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
//链表类，和hashmap一样，大家习惯叫桶，这个桶用来存储linkedList的所有数据
private transient Entry<E> header = new Entry<E>(null, null, null);
//实际存储的数据量
private transient int size = 0;

//构造函数，初始化链表的第一个值
public LinkedList() {
header.next = header.previous = header;
}

//构造函数，把实现collection接口的数据存储入集合内，具体方法细节下面分析
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}

//获取链表上的第一个值
public E getFirst() {
//链表上没值就报错
if (size==0)
throw new NoSuchElementException();
//不为空就返回header后的第一个值（header为此链表上的第一个对象，但是此对象的elements为空）
return header.next.element;
}

//返回链表上的最后一个值
public E getLast()  {
if (size==0)
throw new NoSuchElementException();
//链表上的最后一个值就是header前一个值
return header.previous.element;
}

//移除第一个
public E removeFirst() {
return remove(header.next);
}

//移除最后一个
public E removeLast() {
return remove(header.previous);
}

//添加数据到第一个位置
public void addFirst(E e) {
addBefore(e, header.next);
}

//添加数据到最后一个位置
public void addLast(E e) {
addBefore(e, header);
}

//查看是否包含指定数据
public boolean contains(Object o) {
return indexOf(o) != -1;
}

//返回此链表的大小
public int size() {
return size;
}

//添加数据（默认添加到链表的末尾）
public boolean add(E e) {
addBefore(e, header);
return true;
}

//移除链表上指定的元素
public boolean remove(Object o) {
if (o==null) {
//如果o为空，则对链表进行循环，注意一点，在此比较的时候是用“！=”，所以比较的是内存地址，而e也确实就相        //当于一个指针，一直循环指向链表上的值
for (Entry<E> e = header.next; e != header; e = e.next) {
if (e.element==null) {
//找到值就删除它
remove(e);
return true;
}
}
} else {
//不为空的时候就在链表上找到这个值，然后移除它，此时找到的是与o相等的第一个值
for (Entry<E> e = header.next; e != header; e = e.next) {
if (o.equals(e.element)) {
remove(e);
return true;
}
}
}
return false;
}

//添加一个Collection到集合内
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}

//上面方法的具体业务实现
public boolean addAll(int index, Collection<? extends E> c) {
//index不合理就报错
if (index < 0 || index > size)
throw new IndexOutOfBoundsException("Index: "+index+
", Size: "+size);
//把collection转换成数组，发现数组为空就报错，具体toArray()方法在AbstractCollection有实现
Object[] a = c.toArray();
int numNew = a.length;
if (numNew==0)
return false;
modCount++;
//找出两个对象，successor是index+1处的值（index处的值实际是链表上index+1处的值，因为多了一个elemen        //t为空的header）,predecessor 才是index处的值
Entry<E> successor = (index==size ? header : entry(index));
Entry<E> predecessor = successor.previous;
//遍历，把数组中的值按顺序添加到指定位置
for (int i=0; i<numNew; i++) {
//利用构造函数创建新的对象，根据Entry的内部元素，这个构造函数就相当于在链表上插入数据，但是喊不够完整
Entry<E> e = new Entry<E>((E)a[i], successor, predecessor);
//把前一个数据指向下一个数据的指针移到新创建的e上面（之前是指向successor的）
predecessor.next = e;
//移动这个指针指向新加入的值，
predecessor = e;

//以上两行代码有区别： predecessor.next = e;修改的是predecessor.next这个元素真正在堆中的对象
//predecessor = e;这个仅仅修改的是predecessor的指向，也就相当于修改指针
//当调用对象属相的时候就是在操作这个对象的本身了，如果只是操作声明，也就是栈中的值，那仅仅是修改             //这个指针，如果还不懂就自己创建个组合对象试一下就知道了
}
//循环完了就把successor对象的指向前一个值的指针修改一下，从指向最初的predecessor变成传入数组的最后         //一个值，不懂就仔细想想，画个图就懂了
successor.previous = predecessor;

size += numNew;
return true;
}

//清空
public void clear() {
Entry<E> e = header.next;
//从header的下一个值开始循环到header，各种清空
while (e != header) {
Entry<E> next = e.next;
e.next = e.previous = null;
e.element = null;
e = next;
}
//清理header，结果是都变成空
header.next = header.previous = header;
size = 0;
modCount++;
}

//获取链表index+1处的element
public E get(int index) {
return entry(index).element;
}

//修改指定位置的值，并返回此处原来的值，没啥好说的
public E set(int index, E element) {
Entry<E> e = entry(index);
E oldVal = e.element;
e.element = element;
return oldVal;
}

//在指定位置添加值
public void add(int index, E element) {
addBefore(element, (index==size ? header : entry(index)));
}

//移除指定位置的值
public E remove(int index) {
return remove(entry(index));
}

//返回链表上index+1处的值
private Entry<E> entry(int index) {
if (index < 0 || index >= size)
throw new IndexOutOfBoundsException("Index: "+index+
", Size: "+size);
Entry<E> e = header;
//如果传入的值比size/2要小，就从头开始循环
if (index < (size >> 1)) {
for (int i = 0; i <= index; i++)
e = e.next;
} else {
//反之就从末尾开始循环
for (int i = size; i > index; i--)
e = e.previous;
}
return e;
}

//找到第一个element等于o的对象，并返回此对象的位置，没啥好说的
public int indexOf(Object o) {
int index = 0;
if (o==null) {
for (Entry e = header.next; e != header; e = e.next) {
if (e.element==null)
return index;
index++;
}
} else {
for (Entry e = header.next; e != header; e = e.next) {
if (o.equals(e.element))
return index;
index++;
}
}
return -1;
}

//找到最后一个element等于o的对象，返回此处的位置，也没啥好说的
public int lastIndexOf(Object o) {
int index = size;
if (o==null) {
for (Entry e = header.previous; e != header; e = e.previous) {
index--;
if (e.element==null)
return index;
}
} else {
for (Entry e = header.previous; e != header; e = e.previous) {
index--;
if (o.equals(e.element))
return index;
}
}
return -1;
}

//集合没值返回空，有值就返回第一个值的element
public E peek() {
if (size==0)
return null;
return getFirst();
}

//返回第一个值的element，其实和上一个方法差不多，只不过没值的时候上面一个返回空，这个是报错
public E element() {
return getFirst();
}

//没值返回空，有值就干掉第一个
public E poll() {
if (size==0)
return null;
return removeFirst();
}
//干掉第一个
public E remove() {
return removeFirst();
}

//添加元素到链表末尾
public boolean offer(E e) {
return add(e);
}

//添加元素到链表的开头
public boolean offerFirst(E e) {
addFirst(e);
return true;
}

//和add方法一模一样，好几个添加方法都几乎一样，不用深究，没屁用
public boolean offerLast(E e) {
addLast(e);
return true;
}

//获取第一个值，没值返回空
public E peekFirst() {
if (size==0)
return null;
return getFirst();
}

//获取最后一个值，没值就返回空
public E peekLast() {
if (size==0)
return null;
return getLast();
}

//移除…………不想写了，都一个样
public E pollFirst() {
if (size==0)
return null;
return removeFirst();
}

public E pollLast() {
if (size==0)
return null;
return removeLast();
}

public void push(E e) {
addFirst(e);
}

public E pop() {
return removeFirst();
}

//移除链表上第一个element等于o的对象
public boolean removeFirstOccurrence(Object o) {
return remove(o);
}

//移除链表上最后一个element等于o的对象，和上一个方法想法，注意此处调用的remove，上个方法的remove在之前有封  //装，本质和这个方法一样，只是指针的顺序变成倒叙，但是上个方法的remove传入的参数是object，这个remove传入的  //参数是Entry,但是最终的业务类是一样，重载了一遍而已
public boolean removeLastOccurrence(Object o) {
if (o==null) {
for (Entry<E> e = header.previous; e != header; e = e.previous) {
if (e.element==null) {
remove(e);
return true;
}
}
} else {
for (Entry<E> e = header.previous; e != header; e = e.previous) {
if (o.equals(e.element)) {
remove(e);
return true;
}
}
}
return false;
}

public ListIterator<E> listIterator(int index) {
return new ListItr(index);
}

//实现迭代器，具体还没看··
private class ListItr implements ListIterator<E> {
private Entry<E> lastReturned = header;
private Entry<E> next;
private int nextIndex;
private int expectedModCount = modCount;

ListItr(int index) {
if (index < 0 || index > size)
throw new IndexOutOfBoundsException("Index: "+index+
", Size: "+size);
if (index < (size >> 1)) {
next = header.next;
for (nextIndex=0; nextIndex<index; nextIndex++)
next = next.next;
} else {
next = header;
for (nextIndex=size; nextIndex>index; nextIndex--)
next = next.previous;
}
}

public boolean hasNext() {
return nextIndex != size;
}

public E next() {
checkForComodification();
if (nextIndex == size)
throw new NoSuchElementException();

lastReturned = next;
next = next.next;
nextIndex++;
return lastReturned.element;
}

public boolean hasPrevious() {
return nextIndex != 0;
}

public E previous() {
if (nextIndex == 0)
throw new NoSuchElementException();

lastReturned = next = next.previous;
nextIndex--;
checkForComodification();
return lastReturned.element;
}

public int nextIndex() {
return nextIndex;
}

public int previousIndex() {
return nextIndex-1;
}

public void remove() {
checkForComodification();
Entry<E> lastNext = lastReturned.next;
try {
LinkedList.this.remove(lastReturned);
} catch (NoSuchElementException e) {
throw new IllegalStateException();
}
if (next==lastReturned)
next = lastNext;
else
nextIndex--;
lastReturned = header;
expectedModCount++;
}

public void set(E e) {
if (lastReturned == header)
throw new IllegalStateException();
checkForComodification();
lastReturned.element = e;
}

public void add(E e) {
checkForComodification();
lastReturned = header;
addBefore(e, next);
nextIndex++;
expectedModCount++;
}

final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}

//链表类，没啥，就俩指针
private static class Entry<E> {
E element;
Entry<E> next;
Entry<E> previous;

Entry(E element, Entry<E> next, Entry<E> previous) {
this.element = element;
this.next = next;
this.previous = previous;
}
}

//在entry这个值之前添加e
private Entry<E> addBefore(E e, Entry<E> entry) {
Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);
//修改指针的指向
newEntry.previous.next = newEntry;
newEntry.next.previous = newEntry;
size++;
modCount++;
return newEntry;
}

//刚才说的移除方法
private E remove(Entry<E> e) {
if (e == header)
throw new NoSuchElementException();
//旧的数据存储起来，然后准备返回，修改指针指向
E result = e.element;
e.previous.next = e.next;
e.next.previous = e.previous;
//清空e
e.next = e.previous = null;
e.element = null;
size--;
modCount++;
//返回原来的值
return result;
}

public Iterator<E> descendingIterator() {
return new DescendingIterator();
}

private class DescendingIterator implements Iterator {
final ListItr itr = new ListItr(size());
public boolean hasNext() {
return itr.hasPrevious();
}
public E next() {
return itr.previous();
}
public void remove() {
itr.remove();
}
}

//克隆方法，返回链表的浅表副本，也就是只有这个对象的内存地址不同，内部的属性的内存地址与被克隆的一致
public Object clone() {
LinkedList<E> clone = null;
try {
clone = (LinkedList<E>) super.clone();
} catch (CloneNotSupportedException e) {
throw new InternalError();
}

clone.header = new Entry<E>(null, null, null);
clone.header.next = clone.header.previous = clone.header;
clone.size = 0;
clone.modCount = 0;

for (Entry<E> e = header.next; e != header; e = e.next)
clone.add(e.element);

return clone;
}

//转成数组
public Object[] toArray() {
Object[] result = new Object[size];
int i = 0;
for (Entry<E> e = header.next; e != header; e = e.next)
result[i++] = e.element;
return result;
}

//转换成指定类型的数组
public <T> T[] toArray(T[] a) {
if (a.length < size)
a = (T[])java.lang.reflect.Array.newInstance(
a.getClass().getComponentType(), size);
int i = 0;
Object[] result = a;
for (Entry<E> e = header.next; e != header; e = e.next)
result[i++] = e.element;
//如果传入的数组比此链表的长度要长，则把数组上紧挨着链表最后一个元素给清除，数组上后续的值仍然保留，并未移    //除或者修改
if (a.length > size)
a[size] = null;

return a;
}

private static final long serialVersionUID = 876323262645176354L;

private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {

s.defaultWriteObject();

s.writeInt(size);

for (Entry e = header.next; e != header; e = e.next)
s.writeObject(e.element);
}

private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {

s.defaultReadObject();

int size = s.readInt();

header = new Entry<E>(null, null, null);
header.next = header.previous = header;

for (int i=0; i<size; i++)
addBefore((E)s.readObject(), header);
}
}