LinkedList查询慢、增删快源码解析

LinkedList

linkedList的是双向链表实现的，使用通过内部的Node类实现的。

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

同时LinkedList中的三个成员变量

	/**
	 *	链表的长度
	 */
 	transient int size = 0;

    /**
     * 指向头节点
     */
    transient Node<E> first;

    /**
     * 指向尾节点
     */
    transient Node<E> last;

查询慢

• get（int index）查询指定位置元素

/**
 * 查询元素
 */
public E get(int index) {
  //校验索引
  checkElementIndex(index);
  //查询元素
  return node(index).item;
}

//索引越界抛出 索引越界异常
private void checkElementIndex(int index) {
   if (!isElementIndex(index))throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

//校验索引是否越界
private boolean isElementIndex(int index) {
    return index >= 0 && index < size;
}

//根据索引查询元素
Node<E> node(int index) {
	//判断index 是否小于 size/2 --> 小于的话，使用前半部分数据
    if (index < (size >> 1)) {
        Node<E> x = first;
        //循环寻找index的位置， index 越靠近中心位置，循环次数越多
        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;
    }
}

• 查询慢的原因：

  虽然查询的时候取到list的一半来查询index的位置，但是随着list的size增加， 及index的位置靠近中间位置，会使for循环的次数增多，导致查询变慢的主要原因；

• 解决方法：
  可以采用getFirst()、getLast() 方法减少for次数，增加查询的速度。

//获取头节点
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;
}

增删快

• add（E e）直接添加元素

public boolean add(E e) {
    linkLast(e);
    return true;
}
//添加到链表尾节点上
void linkLast(E e) {
	// l 设置为尾节点
	final Node<E> l = last;
	// 构建添加的 e 的node 节点 newNode
    final Node<E> newNode = new Node<>(l, e, null);
    // 设置链表的尾节点 为新构建的 newNode 节点
    last = newNode;
    //判断 原来尾节点是否为null
    if (l == null)
    	//是 --> 将新添加的节点作为链表的首节点
        first = newNode;
    else
    	//否 --> 将原来的尾节点的 下一个节点指向 新添加的节点
        l.next = newNode;
    //链表 size + 1
    size++;
    modCount++;
}

• add（int index, E e）指定位置添加元素

// index 位置 
// element 元素
public void add(int index, E element) {
  // 校验index是否越界
  checkPositionIndex(index);
  // 判断指定的位置是否是 链表的最后位置
   if (index == size)
   	   // 同上面add（E e）
       linkLast(element);
   else
   	   // 加入指定位置
       linkBefore(element, node(index));
}

void linkBefore(E e, Node<E> succ) {
    // 获取指定index位置 前一个节点（前驱节点）
    final Node<E> pred = succ.prev;
    // 构建 e元素节点， 同时让指定位置的前节点 pred 作为本节点的前节点
    // 而原来index位置的节点作为 本节点的后节点（后继节点），可以理解为将本节点插入到
    // 原节点位置，原节点向后移动
    final Node<E> newNode = new Node<>(pred, e, succ);
    // 将原节点的 前驱节点设置为新添加的节点
    succ.prev = newNode;
    // 判断原节点是否为头节点
    if (pred == null)
    //是 ——> 本节点设置为头节点
        first = newNode;
    else
    // 否 ——> 设置原节点的前驱节点中的后继节点为本节点
        pred.next = newNode;
    // 链表 容量 + 1
    size++;
    modCount++;
}

总结：
LinkedList 插入元素，相对与ArrayList效率是较高的，ArrayList增加元素的时候可能需要扩容和元素的拷贝，增加了开销，而LinkedList 是断开指定位置的链把新节点添加进来即可

删除元素

• remove（int index）删除指定位置元素

public E remove(int index) {
	//校验 index 是否越界
 	checkElementIndex(index);
    return unlink(node(index));
}

E unlink(Node<E> x) {
    // 指定index 位置中的元素
    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;
    // 链表容量 - 1
    size--;
    modCount++;
    // 返回移除的元素
    return element;
}

• remove(Object o) 删除元素

 public boolean remove(Object o) {
 	// 判断 o 是否为 null
    if (o == null) {
    	// 是 -> 从头节点遍历
        for (Node<E> x = first; x != null; x = x.next) {
        	// 若链表中有null的节点
            if (x.item == null) {
            	//删除该节点
                unlink(x);
                return true;
            }
        }
    } else {
    	// 从头节点开始遍历
        for (Node<E> x = first; x != null; x = x.next) {
        	// o = 遍历中的元素
            if (o.equals(x.item)) {
            	// 删除该节点
                unlink(x);
                return true;
            }
        }
    }
    return false;
}