Java集合 LinkedList的原理及使用详解

public static void main(String[] args) {
 List<String> stringList = new LinkedList<>();
 List<String> tempList = new ArrayList<>();
 tempList.add("牛魔王");
 tempList.add("蛟魔王");
 tempList.add("鹏魔王");
 tempList.add("狮驼王");
 tempList.add("猕猴王");
 tempList.add("禺贼王");
 tempList.add("美猴王");
 List<String> stringList2 = new LinkedList<>(tempList);
}

public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, java.io.Serializable{
 transient int size = 0;

 /**
  * Pointer to first node.
  * Invariant: (first == null && last == null) ||
  *   (first.prev == null && first.item != null)
  */
 transient Node<E> first;

 /**
  * Pointer to last node.
  * Invariant: (first == null && last == null) ||
  *   (last.next == null && last.item != null)
  */
 transient Node<E> last;

 /**
  * Constructs an empty list.
  */
 public LinkedList() {
 }

 /**
  * Constructs a list containing the elements of the specified
  * collection, in the order they are returned by the collection's
  * iterator.
  *
  * @param c the collection whose elements are to be placed into this list
  * @throws NullPointerException if the specified collection is null
  */
 public LinkedList(Collection<? extends E> c) {
  this();
  addAll(c);
 }
}

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;
 }
}

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

/**
 * 返回一个指定索引的非空节点.
 */
Node<E> node(int index) {
 // assert isElementIndex(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;
 }
}

public boolean add(E e) {
 linkLast(e);
 return true;
}

/**
 * 设置元素e为最后一个元素
*/
void linkLast(E e) {
 final Node<E> l = last;
 final Node<E> newNode = new Node<>(l, e, null);
 last = newNode;
 if (l == null)
  first = newNode;
 else
  l.next = newNode;
 size++;
 modCount++;
}

//在指定位置添加一个元素
public void add(int index, E element) {
 checkPositionIndex(index);
 if (index == size)
  linkLast(element);
 else
  linkBefore(element, node(index));
}

/**
 * 在一个非空节点前插入一个元素
 */
void linkBefore(E e, Node<E> succ) {
 // assert succ != null;
 final Node<E> pred = succ.prev;
 final Node<E> newNode = new Node<>(pred, e, succ);
 succ.prev = newNode;
 if (pred == null)
  first = newNode;
 else
  pred.next = newNode;
 size++;
 modCount++;
}

//删除某个对象
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;
}
//删除某个位置的元素
public E remove(int index) {
 checkElementIndex(index);
 return unlink(node(index));
}
//删除某节点，并将该节点的上一个节点（如果有）和下一个节点（如果有）关联起来
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 static void main(String[] args) {
 LinkedList<Integer> list = getLinkedList();
 //通过快速随机访问遍历LinkedList
 listByNormalFor(list);
 //通过增强for循环遍历LinkedList
 listByStrengThenFor(list);
 //通过快迭代器遍历LinkedList
 listByIterator(list);
}

/**
 * 构建一个LinkedList集合,包含元素50000个
 * @return
 */
private static LinkedList<Integer> getLinkedList() {
 LinkedList list = new LinkedList();
 for (int i = 0; i < 50000; i++){
  list.add(i);
 }
 return list;
}

/**
 * 通过快速随机访问遍历LinkedList
 */
private static void listByNormalFor(LinkedList<Integer> list) {
 // 记录开始时间
 long start = System.currentTimeMillis();
 int size = list.size();
 for (int i = 0; i < size; i++) {
  list.get(i);
 }
 // 记录用时
 long interval = System.currentTimeMillis() - start;
 System.out.println("listByNormalFor：" + interval + " ms");
}

/**
 * 通过增强for循环遍历LinkedList
 * @param list
 */
public static void listByStrengThenFor(LinkedList<Integer> list){
 // 记录开始时间
 long start = System.currentTimeMillis();
 for (Integer i : list) { }
 // 记录用时
 long interval = System.currentTimeMillis() - start;
 System.out.println("listByStrengThenFor：" + interval + " ms");
}

/**
 * 通过快迭代器遍历LinkedList
 */
private static void listByIterator(LinkedList<Integer> list) {
 // 记录开始时间
 long start = System.currentTimeMillis();
 for(Iterator iter = list.iterator(); iter.hasNext();) {
  iter.next();
 }
 // 记录用时
 long interval = System.currentTimeMillis() - start;
 System.out.println("listByIterator：" + interval + " ms");
}

public static void listByStrengThenFor(LinkedList<Integer> list)
 {
 long start = System.currentTimeMillis();
 Integer localInteger;
 for (Iterator localIterator = list.iterator(); localIterator.hasNext(); 
   localInteger = (Integer)localIterator.next()) {}
 long interval = System.currentTimeMillis() - start;
 System.out.println("listByStrengThenFor：" + interval + " ms");
}