源码学习----LinkedList简析

前言

LinkedList是链表的结构，是双向链表

迭代器是按序遍历的

LinkedList与ArrayList最大的区别就是LinkedList中实现了Collection中的 Queue（Deque）接口 拥有作为双端队列的功能

add方法

先说一下具体思路，作为链表结构，那么添加元素就是在链表的末尾插入元素，这个过程中要考虑：末尾元素为null

public boolean add(E e) {
        linkLast(e);
        return true;
}
void linkLast(E e) {
        //末尾元素为null，该如何处理？
        //末尾为空，插入链表头部，也就是最开始1个元素也没有
        final Node<E> l = last;
        // 初始化新的节点
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;
        // 对last节点进行判断，是否为空
        //第一次进来last是null,新节点赋值给last，但是l是final，所以是空的
        if (l == null)
            //第一次进来插入链表头部
            first = newNode;
        else
            //后续插入链表尾部
            l.next = newNode;
        //链表长度加1
        size++;
        //添加修改次数，这个变量在父类里AbstractList
        modCount++;
    }

remove方法

同样先说一下具体处理的思路：

1. 由于删除的元素可能为null，所以要对o进行判断，否则不论是o为null还是遍历的时候元素为null，都会导致报空指针异常
2. 找到元素后，对前后的元素关系重新维护，要考虑到元素是否在头尾的情况

此处就是删除双向链表的元素的操作。

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

E unlink(Node<E> x) {
  final E element = x.item;
  // 记录前后元素
  final Node<E> next = x.next;
  final Node<E> prev = x.prev;
  // prev为null说明x节点为first节点，则删除后，next为first
  if (prev == null) {
    first = next;
  // 否则 prev的下一个元素为x的next
  } else {
    prev.next = next;
    // 设为null，方便prev的GC
    x.prev = null;
  }
  // 同上
  if (next == null) {
    last = prev;
  } else {
    next.prev = prev;
    // 设为null，方便next的GC
    x.next = null;
  }
  // 设为null，方便GC
  x.item = null;
  size--;
  modCount++;
  return element;
}

iterator分析及FailFast机制

来段代码

public class Test1 {
    public static void main(String[] args) {

        List<String> list1=new LinkedList<>();
        list1.add("2");
        list1.add("3");
        list1.add("4");

        Iterator<String> iterator = list1.iterator();
        while (iterator.hasNext()){
            list1.remove("2");
            System.out.println(iterator.next());
        }
    }
}

大家可以猜猜这段代码运行结果？

那为什么会出现这个问题
这个异常是并发修改异常。也就是一边添加一边修改
我们看下iterator这个方法

public Iterator<E> iterator() {
        return new Itr();
}

Itr这是一个内部类

主要是这句代码int expectedModCount = modCount;在调用list1.iterator()的时候，就把修改次数赋值给expectedModCount这个变量。

那么当执行完list1.remove("2");这句代码，这个时候
modCount的值就是4。

当调用：iterator.next()

public E next() {
      checkForComodification();
      try {
          int i = cursor;
          E next = get(i);
          lastRet = i;
          cursor = i + 1;
          return next;
      } catch (IndexOutOfBoundsException e) {
          checkForComodification();
          throw new NoSuchElementException();
      }
}

checkForComodification检查修改异常

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

这就是FailFast机制。

从源码就就可以知道为什么我们在迭代的过程中对集合进行了修改，就会抛出异常，这么做的目的就是为了防止多线程操作同一个集合而出现的问题。

LinkedList的使用场景

LinkedList作为链表结构的特性，可以保证其在端点操作：如插入以及删除等，速度比ArrayList快，道理很简单，ArrayList在删除后，每次都要把后面的元素往前移（虽然采用的是拷贝方法），而LinkedList只要重新维护前后元素的关系就可以了。

最佳的做法可能是将ArrayList作为默认选择，只有你需要使用额外的功能（个人理解为对Queue的操作），或者当程序的性能因为经常从表中间进行插入和删除而变差的时候，才去选择LinkedList。