LinkedList源码解析

介绍

List 和 Deque 接口的双向链表实现。实现所有可选列表操作，并允许所有元素（包括 null）。所有操作都按照双向链表的预期执行。索引到列表中的操作将从开头或结尾遍历列表，以更接近指定索引的为准

add

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


    void linkLast(E e) {
        //上一个节点,第一次add时last=null
        final Node<E> l = last;
        //新建一个节点
        final Node<E> newNode = new Node<>(l, e, null);
        //最新的节点为last节点
        last = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
    }

set

    public E set(int index, E element) {
        //检查index是否合法
        checkElementIndex(index);
        //查找置顶下标的节点
        Node<E> x = node(index);
        //index节点之前的值,会在set中返回出来
        E oldVal = x.item;
        //index节点设置新的值
        x.item = element;
        return oldVal;
    }

set方法重点在node我们下面贴代码

    Node<E> node(int index) {
        //注释1
        if (index < (size >> 1)) {
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                //重置x的值
                x = x.next;
            return x;
        } else {
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }

node相当于是二分法查找,首先通过index判断要查找的节点在前半段还是后半段从而决定从头开始查找还是从尾部开始查找

 remove

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

直接便利所有节点,比较值是否相等然后删除

 remove(int)

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


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


    

node方法上面已经讲过是查找到指定的节点,下面看一下unlink

  E unlink(Node<E> x) {
     
        final E element = x.item;
        final Node<E> next = x.next;
        final Node<E> prev = x.prev;
        
        //如果上一个为null则当前next将会成为第一个节点
        if (prev == null) {
            first = next;
        } else {
            //因为自身节点会被删除所有next节点直接变成上一个节点中的next
            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;
    }

 unlink方法就是为了重置节点之间的关联关系.

get

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

node方法上面看到了是通过二分法快速查找到指定节点

linked增删改查都看完我们画个图看下linkedList的数据结构

 

    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是个双向链表每个节点都可指向上一个节点,于下一个节点,不需要考虑扩容的问题

由于这种数据结构会导致查找速度较慢需要一个个便利

插入删除速度快不需要扩容与数据位移只需要修改节点直接的关联关系(ArrayList需要考虑扩容,中间插入需要位移后面的数据)