LinkedList详解

介绍

众所周知ArrayList底层数据结构是数组，但是数组有个缺点，虽然查询快，但是增删改会慢因为数组是在连续的位置上面储存对象的应用。当我们删除某一个元素的时候在他后面的元素的索引都会左移，导致开销会很大。所以LinkedList应运而生。

LinkedList底层数据结构

链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。
链表可分为单向链表和双向链表。
一个单向链表包含两个值: 当前节点的值和一个指向下一个节点的链接。

一个双向链表有三个整数值: 数值、向后的节点链接、向前的节点链接。

因为LinkedList 采用的是双向链表所以LinkedList 的增加和删除的操作效率更高，而查找和修改的操作效率较低。

应用场景

1.你需要通过循环迭代来访问列表中的某些元素。
2.需要频繁的在列表开头、中间、末尾等位置进行添加和删除元素操作。

类继承关系

应用案例

案例抄自https://www.runoob.com/java/java-linkedlist.htm

添加元素

public class Test {
    public static void main(String[] args) {
        LinkedList<String> sites = new LinkedList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        System.out.println(sites);
    }
}

在列表开头添加元素

public class Test {
    public static void main(String[] args) {
        LinkedList<String> sites = new LinkedList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        // 使用 addFirst() 在头部添加元素
        sites.addFirst("Wiki");
        System.out.println(sites);
    }
}

在列表结尾添加元素：

public class Test {
    public static void main(String[] args) {
        LinkedList<String> sites = new LinkedList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        // 使用 addLast() 在尾部添加元素
        sites.addLast("Wiki");
        System.out.println(sites);
    }
}

列表开头移除元素

public class Test {
    public static void main(String[] args) {
        LinkedList<String> sites = new LinkedList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        // 使用 removeFirst() 移除头部元素
        sites.removeFirst();
        System.out.println(sites);
    }
}

在列表结尾移除元素

public class Test {
    public static void main(String[] args) {
        LinkedList<String> sites = new LinkedList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        // 使用 removeLast() 移除尾部元素
        sites.removeLast();
        System.out.println(sites);
    }
}

获取列表头部元素

    public static void main(String[] args) {
        LinkedList<String> sites = new LinkedList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        // 使用 getFirst() 获取头部元素
        System.out.println(sites.getFirst());
    }

获取列表结尾的元素

 public static void main(String[] args) {
        LinkedList<String> sites = new LinkedList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        // 使用 getLast() 获取尾部元素
        System.out.println(sites.getLast());
    }

循环获取元素

public static void main(String[] args) {
        LinkedList<String> sites = new LinkedList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        for (int size = sites.size(), i = 0; i < size; i++) {
            System.out.println(sites.get(i));
        }
    }

常用方法

底层原理

无参构造器

    public LinkedList() {
    }

add

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

    void linkLast(E e) {
        //获取最后一个节点的node (如果刚开始没添加数据的时候last是空)
        final Node<E> l = last;
        //构建一个node 节点
        final Node<E> newNode = new Node<>(l, e, null);
        //把刚创建的node节点赋值到最后一个节点
        last = newNode;
        //如果l == null 表示链表上还没有数据
        if (l == null)
            //把刚创建的节点当成头节点
            first = newNode;
        else
         //因为l != null 肯定链表上已经有数据了则将刚创建的节点绑定在l节点的下一个节点
            l.next = newNode;
        size++;
        modCount++;
    }

创建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;
            //当前节点的next 节点因为当前节点是新构建的节点他的next节点肯定是空
            this.next = next;
            //指向当前节点的前一个节点
            this.prev = prev;
        }
    }

get(int index)

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

checkElementIndex(int index)

校验是否超过最大长度限制

    private void checkElementIndex(int index) {
        if (!isElementIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

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

获取元素

判断index在链表的哪边。
遍历查找index或者size-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;
        }
    }