LinkedList的全面说明：

（1）LinkedList底层实现了双向链表和双端队列特点

（2）可以添加任意元素（元素可以重复），包括null.

(3)线程不安全，没有实现同步

LinkedList的底层操作机制：

双向链表的创建：

（1）LinkedList底层维护了一个双向链表

size记录了这个链表里面有多少个元素。

（2）LinkedList中维护了两个属性first和last分别指向首节点和尾节点

相当于底层维护了一个链表，链表存在三个元素。它的属性first直接指向了我们维护的链表的第一个元素，last属性指向链表最后的。而链表所存有的对象的属性为node。Node为内部类

（3）每个节点（Node对象），里面又维护了prev、next、item三个属性，其中通过prev指向前一个，通过next指向后一个节点，最终实现双向链表

（4）所以LinkedList的元素的添加和删除，不是通过数组完成的，相对来说效率较高。进行删除元素时，我们只需要让所删除的后一个节点的prev指向所删除元素的前面元素的prev的节点，让所删除的前一个节点的next指向删除元素的后一个节点的next。

（5）模拟一个简单的双向链表

我们通过代码来实现双向链表：

package com.rgf.list;
@SuppressWarnings({"all"})
public class LinkedList01 {
    public static void main(String[] args) {
        //模拟一个简单的双向链表:
        Node jack = new Node("jack");
        Node jdbc = new Node("jdbc");
        Node java = new Node("java");

        //连接三个结点，形成双向链表
        //实现jack-->jdbc-->java
        jack.next = jdbc;
        jdbc.next = java;
        //实现java-->jdbc-->jack
        java.pre = jdbc;
        jdbc.pre = jack;
        System.out.println("====从头到尾进行遍历=====");
        Node first = jack;  //first引用指向jack,就是双向链表的头结点
        Node last = java;   //让last引用指向java,就是双向链表的尾结点

        //演示，从头到尾进行遍历:
        while (true) {
            if (first == null) {
                break;
            }
            //输出first 信息
            System.out.println(first);
            first = first.next;
        }
        System.out.println("=====从尾到头进行遍历======");
        //演示，从尾到头进行遍历:
        while (true) {
            if (last == null) {
                break;
            }
            //输出last信息
            System.out.println(last);
            last = last.pre;
        }
        //演示：链表的添加对象/数据，是多么的方便
        //要求：在jack和jdbc之间插入一个对象，叫rgf
        //1.先创建一个Node结点，name叫rgf
        Node rgf = new Node("rgf");
        //下面就把smith加入到双向链表了
        jack.next = rgf;
        rgf.next = jdbc;
        jdbc.pre = rgf;
        rgf.pre = jack;
        System.out.println("====从头到尾进行遍历=====");
        //让first再次指向第一个人
        first = jack;  //first引用指向jack,就是双向链表的头结点
        last = java;   //让last引用指向java,就是双向链表的尾结点
        //演示，从头到尾进行遍历:
        while (true) {
            if (first == null) {
                break;
            }
            //输出first 信息
            System.out.println(first);
            first = first.next;
        }
        System.out.println("=====从尾到头进行遍历======");
        //演示，从尾到头进行遍历:
        while (true) {
            if (last == null) {
                break;
            }
            //输出last信息
            System.out.println(last);
            last = last.pre;
        }

    }

    //定义一个Node类，Node对象，Node表示双向链表的一个结点
    static class Node {
        public Object item;  //真正存放数据的地方
        public Node next;  //指向后一个结点
        public Node pre;   //指向前一个结点

        public Node(Object name) {
            this.item = name;
        }

        @Override
        public String toString() {
            return "Node name=" + item;
        }
    }
}

运行界面如下所示：

LinkedList底层源码分析：

LinkedList的增删改查案例：

LinkedList.add的实现代码区如下所示：

LinkedList.add的实现代码区如下所示：
package com.rgf.list;

import java.util.LinkedList;

public class LinkedListCRUD {
    public static void main(String[] args) {
        LinkedList linkedList = new LinkedList();
        linkedList.add(1);

        System.out.println("linkedList="+linkedList);
    }
}
之后，我们进行debug:

点进去之后如下所示：当前只是做了一个初始化：

这时我们进行LinkedList的界面查看如下所示：‘

之后进入之后我们先进行装箱：

之后退出来再进入如下所示：

我们进入了add方法,调用了linkLast，我们只有一个结点，即头结点和尾节点都指向同一个结点。

我们再进行下一步，进入如下所示:
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++;
    }
我们刚开始所存入的值为1，此时last为null,我们继续往下走的时候，所存放数据的地方，l为空，e=1,next也为空，此时我们的新节点里面有前面为null，存放的值为1，后面的next也为null。last指向这个新节点：newNode,进入if语句后，l为空，所以first也指向newNode，所以这个时候，这个结点，三个（last、first、newNode)都指向他。

我们发现此时的为：

我们全部运行完毕之后，点进去如下所示：

我们发现first和last的地址都是513。

我们再此基础上进行添加一行代码，如下所示：
package com.rgf.list;

import java.util.LinkedList;

public class LinkedListCRUD {
    public static void main(String[] args) {
        LinkedList linkedList = new LinkedList();
        linkedList.add(1);
        linkedList.add(2);
       
        System.out.println("linkedList="+linkedList);
    }
}
我们进行查看源码如下所示：

我们发现还是要调用linkLast(e),我们继续进行下一步：

我们进行理解如下所示：

我们运行完毕之后如下所示：

LinkedList删除结点的代码演示如下所示：

remove有三种删除方式：remove()，默认为删除第一个。尾入头出

remove(int index)最其中最复杂的，因为他为删除中间的结点比较麻烦

remove(Object o)对链表里面的某一个对象进行比较，然后删除指定的对象。

我们进行代码设计如下所示：
package com.rgf.list;

import java.util.LinkedList;

public class LinkedListCRUD {
    public static void main(String[] args) {
        LinkedList linkedList = new LinkedList();
        linkedList.add(1);
        linkedList.add(2);

        System.out.println("linkedList="+linkedList);
        //演示删除结点的源码
        linkedList.remove();  //这里默认删除的为第一个
        System.out.println("linkedList="+linkedList);
    }
}
我们下来进行debug的进行判断：

我们进入remove进行查看：

我们再进行下一步进入源码：
 public E removeFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return unlinkFirst(f);
    }
我们发现此时f指向first,指向我们双向列表的第一个结点。而f是不等于空的，防止我们再删除的时候是删除一个空链表的。否则会抛出异常的。

我们真正是靠如下方法进行删除的：
private E unlinkFirst(Node<E> f) {
        // assert f == first && f != null;
        final E element = f.item;
        final Node<E> next = f.next;
        f.item = null;
        f.next = null; // help GC
        first = next;
        if (next == null)
            last = null;
        else
            next.prev = null;
        size--;
        modCount++;
        return element;
    }
我们进行理解如下所示：

LinkedList修改结点的代码演示如下所示：
 linkedList.set(1,999);
        System.out.println("linkedList="+linkedList);
我们进行打开断点如下所示：

我们先进行自由装箱：

我们退出继续进行下一步，我们进入set的方法：

我们进入checkElementIndex方法，点击下一步之后如下所示：

我们进入如下所示：

判断完毕之后我们进入下一行代码：
Node<E> x = 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;
        }
    }

LinkedList删除结点的代码演示如下所示：
 //演示得到某个结点的源码
        //get(1)是得到双向链表的第二个对象
        Object o = linkedList.get(1);
        System.out.println(o);
我们进入get方法源码如下所示：

之后我们进行判断checkElementIndex：

我们再进入isElementIndex方法：

返回之后，我们进入改行代码：

继续进行下一步之后如下所示：
 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;
        }
    }