Java容器之LinkedList源码总结

Java容器之LinkedList源码总结

LinkedList底层是双向链表，既实现了队列的方法又实现了栈的方法。和ArrayList相比它在插入和删除更加高效，在随机访问要低效一些，因为ArrayList的底层是数组。
在阅读本篇文章前参考阅读上一篇
ArrayList

迭代器ListIterator

ListIterator迭代器继承自Iterator，主要有以下功能
1、允许我们向前、向后两个方向遍历 List;
2、在遍历时修改 List 的元素；
3、遍历时获取迭代器当前游标所在位置。

 package gemme.collection;

/**
 * 自定义迭代器ListIterator
 * */
public interface IMyListIterator<E> extends IMyIterator<E> {

    // 下一个元素是否存在
    boolean hasNext();

    // 获取下一个元素
    E next();

    // 移除本元素
    void remove();

    // 上一个元素是否存在
    boolean hasPrevious();

    // 获取上一个元素
    E previous();

    // 获取下一个元素的坐标
    int nextIndex();

    // 获取上一个元素的坐标
    int previousIndex();

    // 更新迭代器最后一次操作的元素为e
    void set(E e);

    // 在游标前面插入一个元素
    void add(E e);
}

队列Queue和双向链表Deque

队列Queue在在链表尾部添加元素，在链表头部移除元素，先进先出

package gemme.collection;

/**
* 自定义队列：先进先出
* */
public interface IMyQueue<E> extends IMyCollection<E> {

  // 在队尾添加一个元素，只能返回true，添加失败抛异常
  boolean add(E e);

  // 在队尾添加一个元素，返回false表示添加失败
  boolean offer(E e);

  // 取出并删除队列头的第一个元素，队列为空时抛异常NoSuchElementException
  E remove();

  // 取出并删除队列头的第一个元素，队列为空时返回null
  E poll();

  // 取出但不删除队列头的第一个元素，队列为空时抛异常NoSuchElementException
  E element();

  // 取出但不删除队列头的第一个元素，队列为空时返回null
  E peek();
}

双向链表Deque，继承了队列Queue，既可以在头部添加或移除，又可以在尾部添加或移除；头部添加头部移除实现了栈的功能，尾部添加头部移除实现了队列的功能。

   package gemme.collection;

/**
 * 自定义双向链表：即实现了队列的功能，有实现了栈的功能
 * 继承了队列接口Queue
 * */
public interface IMyDeque<E> extends IMyQueue<E> {

    // 在链表头添加元素，添加失败只能抛异常
    void addFirst(E e);

    // 在链表尾添加元素，添加失败只能抛异常
    void addLast(E e);

    // 在链表头添加元素，返回表示false表示添加失败
    boolean offerFirst(E e);

    // 在链表尾添加元素，返回表示false表示添加失败
    boolean offerLast(E e);

    // 取出并移除链表头的元素，当链表为空时抛NoSuchElementException异常
    E removeFirst();

    // 取出并移除链表尾的元素，当链表为空时抛NoSuchElementException异常
    E removeLast();

    // 取出并移除链表头的元素，当链表为空时返回NULL
    E pollFirst();

    // 取出并移除链表尾的元素，当链表为空时返回NULL
    E pollLast();

    // 取出链表头的元素，当链表为空时抛NoSuchElementException异常
    E getFirst();

    // 取出链表尾的元素，当链表为空时抛NoSuchElementException异常
    E getLast();

    // 取出链表头的元素，当链表为空时返回NULL
    E peekFirst();

    // 取出链表尾的元素，当链表为空时返回NULL
    E peekLast();



    /**
     * 队列Queue的方法
     * */
    @Override
    boolean add(E e);

    @Override
    boolean offer(E e);

    @Override
    E remove();

    @Override
    E poll();

    @Override
    E element();

    @Override
    E peek();


    /**
     * 栈Stack的方法
     * */
    // 在链表头添加元素，添加失败只能抛异常，等同于#addFirst方法
    void push(E e);

    // 取出并移除链表头的元素，当链表为空时抛NoSuchElementException异常，等同于#removeFist方法
    E pop();
}

LinkedList实现类

LinkedList继承了抽象类抽象类AbstractSequentialList，这里只保留它的继承关系不做具体实现，不影响LinkedList的功能实现

package gemme.collection;

/**
* 自定义抽象类AbstractSequentialList，保留继承关系，不具体实现
* */
public abstract class MyAbstractSequentialList<E> extends MyAbstractList<E> {

}

package gemme.collection;

import java.util.Iterator;
import java.util.ListIterator;
import java.util.NoSuchElementException;

/**
* 自定义LinkedList类，继承了List和Deque，内部数据结构是一个双向链表
* */
public class MyLinkedList<E> extends MyAbstractSequentialList<E>
       implements IMyList<E>, IMyDeque<E> {

   transient int size;

   transient Node<E> first;

   transient Node<E> last;

   public MyLinkedList() {}

   private static class Node<E> {
       E item;
       Node<E> next;
       Node<E> prev;

       Node(Node<E> prev, E item, Node<E> next) {
           this.item = item;
           this.next = next;
           this.prev = prev;
       }
   }

   //
   private void linkFirst(E e) {
       Node<E> f = first;
       Node<E> newNode = new Node(null, e, f);
       if (first == null) {
           last = newNode;
       } else {
           f.prev = newNode;
       }
       first = newNode;
       size++;
   }

   //
   private void linkLast(E e) {
       Node<E> l = last;
       Node<E> newNode = new Node(l, e, null);
       if (last == null) {
           first = newNode;
       } else {
           l.next = newNode;
       }
       last = newNode;
       size++;
   }

   //
   void linkBefore(E e, Node<E> succ) {
       Node<E> preNode = succ.prev;
       Node<E> newNode = new Node(succ.prev, e, succ);
       succ.prev = newNode;
       if (preNode == null) {
           first = newNode;
       } else {
           preNode.next = newNode;
       }
       size++;
   }

   //
   private E unlinkFirst(Node<E> f) {
       Node<E> next = f.next;
       E element = f.item;
       f.item = null;
       f.next = null;
       first = next;
       if (next == null) {
           last = null;
       } else {
           next.prev = null;
       }
       size--;
       return element;
   }

   //
   private E unlinkLast(Node<E> l) {
       E element = l.item;
       Node<E> perv = l.prev;
       l.item = null;
       l.prev = null;
       if (perv == null) {
           first = null;
       } else {
           perv.next = null;
       }
       size--;
       return element;
   }

   // 在链表头添加元素，添加失败只能抛异常
   @Override
   public void addFirst(E e) {
       linkFirst(e);
   }

   // 在链表尾添加元素，添加失败只能抛异常
   @Override
   public void addLast(E e) {
       linkLast(e);
   }

   // 在链表头添加元素，返回表示false表示添加失败
   @Override
   public boolean offerFirst(E e) {
       addFirst(e);
       return true;
   }

   // 在链表尾添加元素，返回表示false表示添加失败
   @Override
   public boolean offerLast(E e) {
       addLast(e);
       return true;
   }

   // 取出并移除链表头的元素，当链表为空时抛NoSuchElementException异常
   @Override
   public E removeFirst() {
       Node<E> f = first;
       if (f == null) {
           throw new NoSuchElementException();
       }
       return unlinkFirst(f);
   }

   // 取出并移除链表尾的元素，当链表为空时抛NoSuchElementException异常
   @Override
   public E removeLast() {
       Node<E> l = last;
       if (l == null) {
           throw new NoSuchElementException();
       }
       return unlinkLast(l);
   }

   // 取出并移除链表头的元素，当链表为空时返回NULL
   @Override
   public E pollFirst() {
       return null;
   }

   // 取出并移除链表尾的元素，当链表为空时返回NULL
   @Override
   public E pollLast() {
       return null;
   }

   // 取出链表头的元素，当链表为空时抛NoSuchElementException异常
   @Override
   public E getFirst() {
       Node<E> f = first;
       if (f == null) {
           throw new NoSuchElementException();
       }
       return f.item;
   }

   // 取出链表尾的元素，当链表为空时抛NoSuchElementException异常
   @Override
   public E getLast() {
       Node<E> l = last;
       if (l == null) {
           throw new NoSuchElementException();
       }
       return l.item;
   }

   // 取出链表头的元素，当链表为空时返回NULL
   @Override
   public E peekFirst() {
       Node<E> f = first;
       return (f == null) ? null : f.item;
   }

   // 取出链表尾的元素，当链表为空时返回NULL
   @Override
   public E peekLast() {
       Node<E> l = last;
       return (l == null) ? null : l.item;
   }

   // 在队尾添加一个元素
   @Override
   public boolean offer(E e) {
       return add(e);
   }

   // 取出并删除队列头的第一个元素，队列为空时抛异常NoSuchElementException
   @Override
   public E remove() {
       return removeFirst();
   }

   // 取出并删除队列头的第一个元素，队列为空时返回null
   @Override
   public E poll() {
       Node<E> f = first;
       return (f == null) ? null : unlinkFirst(f);
   }

   // 取出但不删除队列头的第一个元素，队列为空时抛异常NoSuchElementException
   @Override
   public E element() {
       return getFirst();
   }

   // 取出但不删除队列头的第一个元素，队列为空时抛异常NoSuchElementException
   @Override
   public E peek() {
       Node<E> f = first;
       return (f == null) ? null : f.item;
   }


   // 在链表头添加元素，添加失败只能抛异常，等同于#addFirst方法
   @Override
   public void push(E e) {
       addFirst(e);
   }

   // 取出并移除链表头的元素，当链表为空时抛NoSuchElementException异常，等同于#removeFist方法
   @Override
   public E pop() {
       return removeFirst();
   }


   @Override
   public void add(int index, E element) {
       if (index == size)
           linkLast(element);
       else
           linkBefore(element, node(index));
   }

   @Override
   public E remove(int index) {
       return unlink(node(index));
   }

   @Override
   public E get(int index) {
       return node(index).item;
   }

   @Override
   public E set(int index, E element) {
       Node<E> x = node(index);
       E oldVal = x.item;
       x.item = element;
       return oldVal;
   }

   @Override
   public int size() {
       return size;
   }


   @Override
   public Iterator<E> iterator() {
       return listIterator();
   }

   public ListIterator<E> listIterator() {
       return listIterator(0);
   }

   public ListIterator<E> listIterator(int index) {
       return new MyLinkedList.ListItr(index);
   }
   
   /**
    * 自定义迭代器，保留源码主要功能逻辑，具体请参考源码JDK1.7
    * */
   private class ListItr<E> implements ListIterator<E> {
       private Node<E> lastReturned = null;
       private Node<E> next;
       private int nextIndex;

       ListItr(int index) {
           next = (index == size) ? null : (Node<E>) node(index);
           nextIndex = index;
       }

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

       @Override
       public E next() {
           if (!hasNext()) {
               throw new NoSuchElementException();
           }
           lastReturned = next;
           next = next.next;
           nextIndex++;
           return lastReturned.item;
       }

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

       @Override
       public E previous() {
           if (!hasPrevious()) {
               throw new NoSuchElementException();
           }
           next = (next == null) ? (Node<E>) last : next.prev;
           lastReturned = next;
           nextIndex--;
           return next.item;
       }

       @Override
       public int nextIndex() {
           return nextIndex;
       }

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

       @Override
       public void remove() {
           if (lastReturned == null) {
               throw new IllegalStateException();
           }
           Node<E> lastNext = lastReturned.next;
           unlink(lastNext);
           if (next == lastReturned)
               next = lastNext;
           else
               nextIndex--;
           lastReturned = null;
       }


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

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

   }


   private Node<E> node(int index) {
       if (index < (size >> 1)) {
           // 在链表前半部分，从头到尾访问
           Node<E> f = first;
           for (int i = 0; i < index; i++) {
               f = f.next;
           }
           return f;
       } else {
           // 在链表后半部分，从尾到头访问
           Node<E> l = last;
           for (int i = size - 1; i > index; i--) {
               l = l.prev;
           }
           return l;
       }
   }


   private E unlink(Node<E> x) {
       E element = x.item;
       Node<E> next = x.next;
       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;
       }
       size--;
       return element;
   }

   // 在队尾添加一个元素，只能返回true，添加失败抛异常
   @Override
   public boolean add(E e) {
       linkLast(e);
       return true;
   }
}