LinkedList源码简析

思思问问

1 LinkedList简介

LinkedList是一个实现了<font color="red">List接口</font>和<font color="red">Deque接口</font>的<font color="red">双端链表</font>。

<img src="https://img-blog.csdnimg.cn/20201108105348736.png" />

LinkedList继承于 AbstractSequentialList,实现了 ListDequeCloneablejava.io.Serializable 接口。

LinkedList 实现了 List 接口,表明其能进行链表的高效插入和删除操作。
LinkedList 实现了 Deque 接口,即能将LinkedList当作双端队列使用。
LinkedList 实现了了Cloneable接口,即覆盖了函数clone(),能够克隆。
LinkedList 实现了java.io.Serializable接口,这意味着LinkedList 支持序列化,能通过序列化传输数据。

LinkedList不是线程安全的,如果想使LinkedList变成线程安全的,可以调用静态类Collections类中的synchronizedList方法

List list=Collections.synchronizedList(new LinkedList(...));

2 成员属性

// 总节点数
transient int size = 0;
// 头节点
transient Node<E> first;
// 尾节点
transient Node<E> last;

可以发现LinkedList是基于双向链表实现的,使用 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的结构如下:

3 构造方法

// 空参的构造方法,只生成了对象
public LinkedList() {
}

public LinkedList(Collection<? extends E> c) {
    // 先构造一个空链表
    this();
    // 添加Collection中的元素
    addAll(c);
}

4 常用方法

4.1 添加元素

add(E e) :将元素添加到链表尾部

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

add(int index,E e):在指定位置添加元素

public void add(int index, E element) {
        checkPositionIndex(index);// 检查索引index是否处于[0-size]之间

        if (index == size)
            linkLast(element);// 添加在链表尾部
        else 
            linkBefore(element, node(index));// 插入到index所指位置的节点前面
    }
    
    /**
     * 将新节点插入到指定节点前面
     */
    void linkBefore(E e, Node<E> succ) {
        // 取出指定位置的前一个节点
        final Node<E> pred = succ.prev;
        // 构建新节点,pred指定位置的前驱节点,succ指定位置,e是添加的元素
        final Node<E> newNode = new Node<>(pred, e, succ);
        // 指定节点的前驱节点指向要插入的节点。
        succ.prev = newNode;
        // 如果指定位置的前驱节点为空,即指定位置succ是头节点,即newNode设为头节点
        if (pred == null)
            first = newNode;
        else
            pred.next = newNode; // 不为空,原位置的前驱节点的后置节点设置为新节点。
        size++;
        modCount++;
    }

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

    private boolean isPositionIndex(int index) {
        return index >= 0 && index <= size;// 检查索引index是否处于[0-size]之间
    }

addAll(Collection c ):将集合元素插入到链表中

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

public boolean addAll(int index, Collection<? extends E> c) {
        // 1、检查index范围是否在size之内
        checkPositionIndex(index);

        // 2、把集合的数据存到对象数组中
        Object[] a = c.toArray();
        int numNew = a.length;
        if (numNew == 0)
            return false;

        // 3、得到插入位置的前驱节点和后继节点
        Node<E> pred, succ;
        // 如果插入位置为尾部,前驱节点为last,后继节点为null
        if (index == size) {
            succ = null;
            pred = last;
        }
        // 否则,调用node()方法得到后继节点,再得到前驱节点
        else {
            succ = node(index);
            pred = succ.prev;
        }

        // 4、遍历数据将数据插入
        for (Object o : a) {
            @SuppressWarnings("unchecked") E e = (E) o;
            // 创建新节点
            Node<E> newNode = new Node<>(pred, e, null);
            // 如果插入位置在链表头部
            if (pred == null)
                // 把前一个节点向后指向newNode
                first = newNode;
            else
                pred.next = newNode;
            // 在if-else之外,如果没有这语句,pred节点就固定是那一个节点,所以需要在每一次循环内更换节点
            pred = newNode;
        }

        // 如果插入位置在尾部,重置last节点
        if (succ == null) {
            last = pred;
        }
        // 插入的链表与先前链表连接起来
        else {
            pred.next = succ;
            succ.prev = pred;
        }

        size += numNew;
        modCount++;
        return true;
    }    

addFirst(E e): 将元素添加到链表头部

 public void addFirst(E e) {
        linkFirst(e);
    }

private void linkFirst(E e) {
        // 找到当前头节点
        final Node<E> f = first;
        final Node<E> newNode = new Node<>(null, e, f);// 新建节点,以之前头节点为后继节点
        // 新节点为头节点
        first = newNode;
        // 如果链表为空,last节点也指向新节点
        if (f == null)
            last = newNode;
        // 否则,将之前头节点的前驱指针指向新节点,也就是指向前一个元素
        else
            f.prev = newNode;
        size++;
        modCount++;
    }

addLast(E e): 将元素添加到链表尾部,与 add(E e) 方法一样

public void addLast(E e) {
        linkLast(e);
    }

4.2 查找元素

get(int index): 根据指定索引返回数据

public E get(int index) {
        // 检查index是否在合法位置
        checkElementIndex(index);
        // 调用Node(index)去找到index对应的node然后返回它的值item
        return node(index).item;
    }

获取头节点(index=0)数据方法:

public E getFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return f.item;
    }
public E element() {
        return getFirst();
    }
public E peek() {
        final Node<E> f = first;
        return (f == null) ? null : f.item;
    }

public E peekFirst() {
        final Node<E> f = first;
        return (f == null) ? null : f.item;
     }

区别:
getFirst()element() 方法将会在链表为空时,抛出异常;

element()方法的内部就是使用getFirst()实现的。它们会在链表为空时,抛出NoSuchElementException 。

获取尾节点(index=-1)数据方法:

 public E getLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return l.item;
    }
 public E peekLast() {
        final Node<E> l = last;
        return (l == null) ? null : l.item;
    }

两者区别:
getLast() 方法在链表为空时,会抛出NoSuchElementException;而peekLast() 只是会返回 null

4.3 删除元素

remove()removeFirst()、pop(): 删除头节点

public E pop() {
        return removeFirst();
    }
public E remove() {
        return removeFirst();
    }
public E removeFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return unlinkFirst(f);
    }

removeLast()、pollLast(): 删除尾节点

public E removeLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return unlinkLast(l);
    }
public E pollLast() {
        final Node<E> l = last;
        return (l == null) ? null : unlinkLast(l);
    }

区别: removeLast()在链表为空时将抛出NoSuchElementException;pollLast()方法返回null。

remove(Object o): 删除指定元素

public boolean remove(Object o) {
        // 如果要删除对象为null
        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(Object o)即可,不过该方法一次只会删除一个匹配的对象,如果删除了匹配对象,返回true,否则false。

unlink(Node<E> x) 方法:删除指定节点

E unlink(Node<E> x) {
        final E element = x.item;
        // 得到x的后继节点
        final Node<E> next = x.next;
        // 得到x的前驱节点
        final Node<E> prev = x.prev;

        // x是头节点
        if (prev == null) {
            // 如果删除的节点是头节点,令头节点指向该节点的后继节点
            first = next;
        } else {
            // 将前驱节点的后继节点指向x的后继节点
            prev.next = next;
            // 删除x的前指向
            x.prev = null;
        }

        // x是尾节点
        if (next == null) {
            last = prev;// 如果删除的节点是尾节点,令尾节点指向该节点的前驱节点
        } else {
            next.prev = prev;
            x.next = null;
        }
        
        // 删除指定节点内容
        x.item = null;
        size--;
        modCount++;
        return element;
    }

remove(int index):删除指定位置的元素

public E remove(int index) {
        // 检查index范围
        checkElementIndex(index);
        // 将节点删除
        return unlink(node(index));
    }

4.4 修改元素

set(int index, E element)方法:修改指定节点元素

    public E set(int index, E element) {
        // 检查是否越界
        checkElementIndex(index);
        // 根据索引查找节点
        Node<E> x = node(index);
        // oldVal存放需要改变的内容
        E oldVal = x.item;
        x.item = element;
        // 返回改变前的值
        return oldVal;
    }

5 ArrayList与LinkedList异同

异同ArrayListLinkedList
是否保证线程安全
插入和删除是否受元素位置的影响
是否支持快速随机访问
是否实现了RandomAccess接口
底层数据结构Object数组双向链表(JDK1.6 之前为循环链表,JDK1.7 取消了循环)
内存空间占用扩容机制导致list 列表的结尾会预留一定的容量空间每一个元素都需额外消耗存放后继/前驱的空间

参考

LinkedList源码分析(一)

LinkedList源码分析(二)

阅读 373

我思
Stay Hungry, Stay Foolish!

Stay Hungry, Stay Foolish!

13 声望
2 粉丝
0 条评论

Stay Hungry, Stay Foolish!

13 声望
2 粉丝
文章目录
宣传栏