java.util.LinkedList

1. 类定义

public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>,Deque<E>,Cloneable,java.io.Serializable;

1. 域

transient int size = 0 ;  //链表初始容量为0

transient Node<E> first; //指向第一个节点的指针

transient Node<E> last; //指向最后一个节点的指针

1. 方法

public linkedList(){} //实例化一个空的链表

public LinkedList(Collection<? extends E> c){ //将集合c插入链表
 this();
 addAll(c);
}

1. 私有方法

//将e插到链表首位
private void linkFirst(E e){
final Node<E> f = first;
final Node<E> newNode = new Node<E>(null,e,f);
first = newNode;
if(f==null)last=newNode;
else f.prev=newNode;
size++;
modCount++;
}

//将e插入到链表最后
void linkLast(E e){
 final Node<E> l = last;
 final Node<E> newNode = new Node<E>(l,e,null);
 last=newNode;
 if(l==null)first=newNode;
 else l.next=newNode;
 size++;
 modCount++;
}

//在指针succ之前插入一个元素e,succ必须为非空指针
void linkBefore(E e, Node<E> succ){
 final Node<E> pred=succ.prev;
 final Node<E> newNode = new Node<>(pred,e,succ);
 if(pred==null)
 first=newNode;
 else pred.next=newNode;
 size++;
 modCount++;
}

//删除第一个节点,f==first&&f!=null
private E unlinkFirst(Node<E> f){
 final E element = f.item;
 final Node<E> next =f.next;
 f.item=null;
 f.next=null;
 first=next;
 if(next==null)last=null;
 else next.prev=null;
 size--;
 modCount++;
 return element;
}

//删除最后一个节点，l==last&&l!=null
private E unlinkLast(Node<E> l){
final E element = l.item;
final Node<E> prev = l.prev;
l.item=null;
l.prev=null;
last=prev;
if(prev==null)first=null;
else prev.next=null;
size--;
modCount++;
return element;
}

//删除节点x
E  unlink(Node<E> x){
final E element = x.item;
final Node<E> next = x.next;
final Node<E> prev = x.prev;
if(prev==null)first=next;
else {
  prev.next=next;
  x.prev=null;
}
if(next==null){
 last==prev;
}
else{
next.prev=prev;
x.next=null;
}
x.item=null;
size--;
modCount++;
return element;
}

//获取链表头元素
public E getFirst(){
final Node<E> f = first;
if(f==null)throw new NoSuchElementException();
return f.item;
}
//获取链表尾元素
public E getLast(){
final Node<E> l = last;
if(l==null)throw new NoSuchElementException();
return l.item;
}

//删除第一个元素
public E removeFirst(){
final Node<E> f = first;
if(f==null)throw new NoSuchElementException();
return unlinkFirst(f);
}

//删除最后一个元素
public E removeLast(){
final Node<E> l = last;
if(last==null)throw new NoSuchElementException();
unlinkLast(l);
}

//在链表头插入元素
public void addFirst(E e){
 linkFirst(e);
}

public void addLast(E e) {
        linkLast(e);
    }
    //是否包含元素o
public boolean contains(Object o) {
        return indexOf(o) != -1;
    }
    //返回链表大小
 public int size() {
        return size;
    }
    //添加一个元素（在链表末尾）
public boolean add(E e) {
        linkLast(e);
        return true;
    }
    //从头遍历链表，删除第一个遇到的与o相同的元素,该遍历用for循环遍历
public boolean remove(Object o) {
        if (o == null) {
            for (Node<E> x = first; x != null; x = x.next) {
                if (x.item == null) {
                    unlink(x);
                    return true;
                }
            }
        } else {
            for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item)) {
                    unlink(x);
                    return true;
                }
            }
        }
        return false;
    }

//将集合c插入到链表末尾
public boolean addAll(Collection<? extends E> c) {
        return addAll(size, c);
    }

//在链表指定位置插入集合c
public boolean addAll(int index, Collection<? extends E>c){
checkPositionIndex(index);
Object[] a = c.toArray();
int numNew = a.length;
if(newNew == 0)return false;
Node<E> pred,succ;
if(index==size){
succ=null;
pred=last;
}else{
 succ=node(index);
 pred=succ.prev;
}
for(Object o :a){
Node<E> newNode = new Node<>(pred,e,null);
if(pred==null)first=newNode;
else pred.next=newNode;
pred=newNode;
}
if(succ==null)last=pred;
else{
pred.next=succ;
succ.prev=pred;
}
size+=newNew;
modCount++;
return true;
}

//清空链表
public void clear(){
for(Node<E> x=first;x!=null;){
 Node<E> next=x.next;
 x.item=null;
 x.prev=null;
 x.next=null;
 x=next;
}
first=last=null;
size=0;
modCount++;
}

//获取指定位置的元素
pubilc E get(int index){
 checkElementIndex(index);
 return nod(index).item;
}

//替换指定位置的元素,返回替换之前该位置的值
public E set(int index, E element) {
        checkElementIndex(index);
        Node<E> x = node(index);
        E oldVal = x.item;
        x.item = element;
        return oldVal;
    }
//在指定位置插入一个元素
public void add(int index, E element) {
        checkPositionIndex(index);

        if (index == size)
            linkLast(element);
        else
            linkBefore(element, node(index));
    }

//删除指定的元素,并返回该元素
public E remove(int index) {
        checkElementIndex(index);
        return unlink(node(index));
    }

//判断index位置是否存在
private boolean isElementIndex(int index){
return index>=0&&index<size;
}
//针对迭代器或者add操作，判断Index是否是一个合法的位置
private boolean isPositionIndex(int index){
return index>=0 && index<= size;
}
//返回越界提示信息
private String outOfBoundsMsg(int index) {
        return "Index: "+index+", Size: "+size;
    }
//检查Index是否是一个合法的元素位置
private void checkElementIndex(int index) {
        if (!isElementIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
//检查index是否是一个合法的增加元素位置
private void checkPositionIndex(int index) {
        if (!isPositionIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
//返回第一个元素o的位置，没有则返回-1
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;
    }

//返回o在链表中最后出现的位置
public int lastIndexOf(Object o) {
        int index = size;
        if (o == null) {
            for (Node<E> x = last; x != null; x = x.prev) {
                index--;
                if (x.item == null)
                    return index;
            }
        } else {
            for (Node<E> x = last; x != null; x = x.prev) {
                index--;
                if (o.equals(x.item))
                    return index;
            }
        }
        return -1;
    }
*********************以下是队列操作****************************
//返回队列头元素
public E peek(){
final Node<E> f = first;
return (f == null) ? null : f.item;
}
//返回头节点元素
public E element() {
        return getFirst();
    }
//删除并返回头节点元素
public E poll() {
        final Node<E> f = first;
        return (f == null) ? null : unlinkFirst(f);
    }
//删除并返回头节点元素
public E remove() {
        return removeFirst();
    }
//将具体元素插入表尾
 public boolean offer(E e) {
        return add(e);
    }
//将元素插入表头
  public boolean offerFirst(E e) {
        addFirst(e);
        return true;
    }
//将具体元素插入表尾
public boolean offerLast(E e) {
        addLast(e);
        return true;
    }
//返回但不删除表头元素
public E peekFirst() {
        final Node<E> f = first;
        return (f == null) ? null : f.item;
     }
//返回但不删除表尾元素
public E peekLast() {
        final Node<E> l = last;
        return (l == null) ? null : l.item;
    }
//删除并返回表头元素
public E pollFirst() {
        final Node<E> f = first;
        return (f == null) ? null : unlinkFirst(f);
    }
//删除并返回表尾元素
public E pollLast() {
        final Node<E> l = last;
        return (l == null) ? null : unlinkLast(l);
    }
****************栈操作********************
//压栈,栈顶为表头
 public void push(E e) {
        addFirst(e);
    }
//出栈
public E pop() {
        return removeFirst();
    }
//删除第一次遇到的o
public boolean removeFirstOccurrence(Object o) {
        return remove(o);
    }
//删除最后一次遇到的o
public boolean removeLastOccurrence(Object o) {
        if (o == null) {
            for (Node<E> x = last; x != null; x = x.prev) {
                if (x.item == null) {
                    unlink(x);
                    return true;
                }
            }
        } else {
            for (Node<E> x = last; x != null; x = x.prev) {
                if (o.equals(x.item)) {
                    unlink(x);
                    return true;
                }
            }
        }
        return false;
    }
//返回链表的迭代器
public ListIterator<E> listIterator(int index) {
        checkPositionIndex(index);
        return new ListItr(index);
    }

//返回链表的倒序迭代器（从表尾遍历到表头）
public Iterator<E> descendingIterator() {
        return new DescendingIterator();
    }
//返回包含链表所有元素的数组
public Object[] toArray() {
        Object[] result = new Object[size];
        int i = 0;
        for (Node<E> x = first; x != null; x = x.next)
            result[i++] = x.item;
        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 (Node<E> x = first; x != null; x = x.next)
            result[i++] = x.item;

        if (a.length > size)
            a[size] = null;

        return a;
    }

1. 私有类Node

//定义链表节点
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;
        }
    }

//定义链表的迭代器
private class ListItr implements ListIterator<E> {
        private Node<E> lastReturned = null;
        private Node<E> next;
        private int nextIndex;
        private int expectedModCount = modCount;

        ListItr(int index) {
            // assert isPositionIndex(index);
            next = (index == size) ? null : node(index);
            nextIndex = index;
        }

        public boolean hasNext() {
            return nextIndex < size;
        }

        public E next() {
            checkForComodification();
            if (!hasNext())
                throw new NoSuchElementException();

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

        public boolean hasPrevious() {
            return nextIndex > 0;
        }

        public E previous() {
            checkForComodification();
            if (!hasPrevious())
                throw new NoSuchElementException();

            lastReturned = next = (next == null) ? last : next.prev;
            nextIndex--;
            return lastReturned.item;
        }

        public int nextIndex() {
            return nextIndex;
        }

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

        public void remove() {
            checkForComodification();
            if (lastReturned == null)
                throw new IllegalStateException();

            Node<E> lastNext = lastReturned.next;
            unlink(lastReturned);
            if (next == lastReturned)
                next = lastNext;
            else
                nextIndex--;
            lastReturned = null;
            expectedModCount++;
        }

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

        public void add(E e) {
            checkForComodification();
            lastReturned = null;
            if (next == null)
                linkLast(e);
            else
                linkBefore(e, next);
            nextIndex++;
            expectedModCount++;
        }

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

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