LinkedList源码解析-CSDN博客

本文链接：https://blog.csdn.net/lichunyu7199/article/details/131918252

1.类结构

LinkedList底层采用双向链表结构存储数据，允许重复数据和null值，长度没有限制。

QQ20210220-112151@2x

每个节点内部类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;
        }
}

Node节点包含item（存储数据）,prev（前继节点）和next（后继节点）。数组内存地址必须连续，而链表就没有这个限制，Node可以分布于各个内存地址，他们之间的关系通过prev和next维护。

LinkedList类层次结构图：

可以看到LinkedList实现了Deque接口，所以包含一些队列方法

LinkedList包含如下成员变量：

    //元素个数，默认为0
    transient int size = 0;
    //表示第一个节点，第一个节点必须满足(first == null && last == null) ||(first.prev == null && first.item != null)
    transient Node<E> first;
    //表示最后一个节点，最后一个节点必须满足 (first == null && last == null) ||(last.next == null && last.item != null)
    transient Node<E> last;

2.方法解析

2.1 构造函数

LinkedList()：

public LinkedList() {
}

空参构造函数，默认size为0，每次添加新元素都要创建Node节点。

LinkedList(Collection<? extends E> c):

public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c);
}

public boolean addAll(Collection<? extends E> c) {
        return addAll(size, c);
}

public boolean addAll(int index, Collection<? extends E> c) {
        checkPositionIndex(index);

        Object[] a = c.toArray();
        int numNew = a.length;
        if (numNew == 0)
            return false;

        Node<E> pred, succ;
        if (index == size) {
            //在尾部添加
            succ = null;
            pred = last;
        } else {
            succ = node(index);
            pred = succ.prev;
        }

        //循环创建节点，设置pred节点的next指向
        for (Object o : a) {
            @SuppressWarnings("unchecked") E e = (E) o;
            Node<E> newNode = new Node<>(pred, e, null);
            if (pred == null)
                first = newNode;
            else
                pred.next = newNode;
            pred = newNode;
        }

        if (succ == null) {
            last = pred;
        } else {
            pred.next = succ;
            succ.prev = pred;
        }
        
        //size数增加numNew
        size += numNew;
        //修改次数+1
        modCount++;
        return true;
    }

该构造函数用于创建LinkedList,并往里面添加指定集合元素。

2.2 add(E e)

public boolean add(E e) {
        //默认尾部插入
        linkLast(e);
        return true;
 }

void linkLast(E e) {
        //获取最后一个节点
        final Node<E> l = last;
        //创建一个新节点，prev为原链表的最后一个节点，next为null
        final Node<E> newNode = new Node<>(l, e, null);
        //更新last为新节点
        last = newNode;
        if (l == null)
            //如果原链表的最后一个节点为null，说明原链表没有节点，将新节点赋值给first
            first = newNode;
        else
            //否则更新原链表的最后一个节点的next节点为新节点
            l.next = newNode;
        //size递增
        size++;
        //修改次数递增
        modCount++;
}

采用尾插法插入元素，不涉及节点的遍历操作，速度非常快。

add(int index, E element)，指定下标插入元素

public void add(int index, E element) {
        //下标合法性检查
        checkPositionIndex(index);

        if (index == size)
            //如果插入下标等于size，说明是在尾部插入
            linkLast(element);
        else
            //否则在指定下标节点前插入
            linkBefore(element, node(index));
}

private void checkPositionIndex(int index) {
        if (!isPositionIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

private boolean isPositionIndex(int index) {
        return index >= 0 && index <= size;
}




void linkLast(E e) {
        //获取最后一个节点
        final Node<E> l = last;
        //创建一个新节点，prev为原链表的最后一个节点，next为null
        final Node<E> newNode = new Node<>(l, e, null);
        //更新last为新节点
        last = newNode;
        if (l == null)
            //如果原链表的最后一个节点为null，说明原链表没有节点，将新节点赋值给first
            first = newNode;
        else
            //否则更新原链表的最后一个节点的next节点为新节点
            l.next = newNode;
        //size递增
        size++;
        //修改次数递增
        modCount++;
    }

void linkBefore(E e, Node<E> succ) {
        // assert succ != null;
        //succ为原链表指定index位置的节点，获取其prev节点
        final Node<E> pred = succ.prev;
        //创建新节点，并指定prev节点和next节点
        final Node<E> newNode = new Node<>(pred, e, succ);
        //将原链表指定index位置的节点的prev更新为newNode
        succ.prev = newNode;
        if (pred == null)
            //如果链表指定index位置的节点prev为null，说明index位置的节点为首节点，将新节点赋值给first
            first = newNode;
        else
            //否则更新原链表指定index位置的节点的prev节点的next节点为新节点
            pred.next = newNode;
        //size递增
        size++;
        //修改次数递增
        modCount++;
    }

Node<E> node(int index) {
        // assert isElementIndex(index);
        // 采用二分法遍历每个Node节点，直到找到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;
        }
    }

代码主要逻辑是设置节点的prev和next指向。除了头插法和尾插法外，在链表别的位置插入新节点，涉及到节点的遍历操作。通常说链表插入速度快，指的是插入节点改变前后节点的引用过程很快。

2.3 remove(Object o)

public boolean remove(Object o) {
        //由于链表允许元素为null，所以要先判断删除的元素是否为null，
        if (o == null) {
            //遍历链表，找到第一个为元素为null的节点,并调用unlink()方法,改变删除节点的prev和next节点的前继和后继节点
            for (Node<E> x = first; x != null; x = x.next) {
                if (x.item == null) {
                    unlink(x);
                    return true;
                }
            }
        } else {
            //否则遍历链表，找到第一个元素和要删除元素匹配的节点，并调用unlink()方法,改变删除节点的prev和next节点的前继和后继节点
            for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item)) {
                    unlink(x);
                    return true;
                }
            }
        }
        return false;
    }


unlink(Node<E> x) {
        // assert x != null;
        //x为指定index位置的节点，获取x节点的item
        final E element = x.item;
        //获取指定index位置的节点的next
        final Node<E> next = x.next;
        //获取指定index位置的节点的prev
        final Node<E> prev = x.prev;

        if (prev == null) {
            //如果指定index位置的节点的prev为null，将指定index位置的节点的next节点赋值给first
            first = next;
        } else {
            //否则将指定index位置的节点的next节点赋值给 指定index位置的节点的prev节点的next
            prev.next = next;
            //指定index位置的节点的prev赋值为null，便于回收
            x.prev = null;
        }

        if (next == null) {
            //如果指定index位置的节点next为null，将指定index位置的节点的prev节点赋值给last
            last = prev;
        } else {
            //否则将将指定index位置的节点的prev节点赋值为 指定index位置的节点的next节点的prev
            next.prev = prev;
            //将指定index位置的节点的next赋值为null，便于回收
            x.next = null;
        }

        //将指定index位置的节点的item赋值为null
        x.item = null;
        //size递减
        size--;
        //修改次数递增
        modCount++;
        return element;
    }

删除指定元素的节点

remove(int index) 删除指定下标的节点

public E remove(int index) {
        //下标合法性校验
        checkElementIndex(index);
        //获取指定index位置的节点，然后删除
        return unlink(node(index));
}

通过调用node(index)方法找到要删除的节点，再调用unlink()方法,改变删除节点的prev和next节点的前继和后继节点，unlinke()方法同上。

2.4 get(int index)

get(int index) 获取指定下标的元素

 public E get(int index) {
        //下标合法性校验
        checkElementIndex(index);
        //调用node(index)方法，获取指定index位置的节点，然后获取其item元素
        return node(index).item;
    }

2.5 set(int index, E element)

set(int index, E element) 设置指定index下标节点的item为指定值

public E set(int index, E element) {
        //下标合法性检测
        checkElementIndex(index);
        //获取index下标节点
        Node<E> x = node(index);
        //获取旧值
        E oldVal = x.item;
        //设置新值
        x.item = element;
        return oldVal;
    }

可以看到set()方法也需要通过调用node方法遍历获取目标节点

剩下的方法可以自己阅读源码。