简单分析LinkedList双链表核心方法

先来简单了解一下LinkedList双链表
LinkedList的底层是一个双向链表；添加、删除元素效率高；按照索引查找效率低。可以两个方向查询；
LinkedList中有3个成员变量 ：size是元素的个数，first：永远指向首个节点元素；Last指向后一个节点元素；相对于单链表 节点信息，双链表的每个元素组成包含了3部分内容：前节点信息+业务数据+后节点信息
LinkedList是非同步的即线程不安全；
分析LinkedList添加动作：首先创建一个方法栈，方法栈中实现main方法，初始化LinkedList，即在堆中创建一个对象，该对象有3个成员变量即：size，first,Last 这个时候 size是等于0的，first和Last都是为null的；然后再去调用add方法，add方法中传输一个参数 Object类型即：要添加到集合中的数据；
然后开着执行add方法：
final Node l = last;
将最后一个节点元素 last（last=null）赋值给 l
final Node newNode = new Node(l, e, null);
创建一个新的对象：node是linkedList的实体方法 包含了first(首节点)，item（业务数据）,Last（最后节点）新创建的对象的首个节点赋值给了l,这个时候l是等于null的，item为添加到LinkedList中的数据，last就赋值为了null,
last = newNode;
这个时候就将新创建的这个双链表对象指向了最后一个元素
if (l == null)
first = newNode;
else
l.next = newNode;
因为添加的是第一个元素 所以l是null 要走的代码是
first = newNode;
将新创建的对象赋值给首个对象
这个时候linkedList的物理模型为首节点指向newNode, Last的last则是指向了newNode,首节点和最后的节点都指向了newNode 然后还有个比较重要的步骤 就是size++；
不理解没关系，咱们再添加一个元素
final Node l = last;
这个时候l指向了newNode 假设newNode的地址为X10001
final Node newNode1 = new Node(l, e, null);
然后在新建一个newNode1 这个时候l指向了newNode 这个l为first ，e还是要添加的对象，last则指向null
last = newNode1;
然后将newNode1赋值给Last

   if (l == null)
    
    first = newNode;
else
    l.next = newNode;

这个时候的l就不为null了所以这次走的是
l.next = newNode1;
将l的下个节点指向了newNode1的地址
现在的Last指向的就为newNode1了
再添加还是依次替换元素的指向
上代码
还是实现List接口

/**
 * 模拟list实现接口
 */
public interface List {
    // 返回线性表的大小，即数据元素的个数。
    public int size();
    // 返回线性表中序号为 i 的数据元素 根据下标获取元素
    public Object get(int i);
    // 如果线性表为空返回 true，否则返回 false。判断是否为空
    public boolean isEmpty();
    // 判断线性表是否包含数据元素 e 判断集合中是否包含某元素
    public boolean contains(Object e);
    // 返回数据元素 e 在线性表中的序号 返回指定元素的下标
    public int indexOf(Object e);
    // 将数据元素 e 插入到线性表中 i 号位置 插入到指定下标的位置
    public void add(int i, Object e);
    // 将数据元素 e 插入到线性表末尾 添加元素
    public void add(Object e);
    // 将数据元素 e 插入到元素 obj 之前 将指定元素插入到标记元素之前
    public boolean addBefore(Object obj, Object e);
    // 将数据元素 e 插入到元素 obj 之后 将指定元素插入到标记元素之后
    public boolean addAfter(Object obj, Object e);
    // 删除线性表中序号为 i 的元素,并返回之 删除指定下标的元素
    public Object remove(int i);
    // 删除线性表中第一个与 e 相同的元素 删除第一个元素为e 的数据
    public boolean remove(Object e);
    // 替换线性表中序号为 i 的数据元素为 e，返回原数据元素 替换下标中的元素为指定元素
    public Object replace(int i, Object e);
    public Iterator iterator(); //实现迭代器

}

然后实现List接口

/**
 * 双链表实现
 */
public class LinkedList implements List {

    transient int size = 0;//双链表中的元素个数

    transient Node  first;//双链表中的首个节点

    transient Node last;//双链表的最后一个节点


    @Override
    public int size() {
        return size;
    }

    @Override
    public Object get(int index) {
        return  node(index).item;
    }

    @Override
    public boolean isEmpty() {
        return size==0;
    }

    @Override
    public boolean contains(Object e) {
        return false;
    }

    @Override
    public int indexOf(Object e) {
        return 0;
    }

    @Override
    public void add(int index, Object element) {
        if (index == size)
            linkLast(element);
        else
            linkBefore(element, node(index));
    }
    void linkBefore(Object e, Node succ) {
        // assert succ != null;
        final Node pred = succ.prev;
        final Node newNode = new Node(pred, e, succ);
        succ.prev = newNode;
        if (pred == null)
            first = newNode;
        else
            pred.next = newNode;
        size++;
    }

    Node node(int index) {
        // assert isElementIndex(index);

        if (index < (size >> 1)) {
            Node x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else {
            Node x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }

    @Override
    public void add(Object e) {
        linkLast(e);
    }

    void linkLast(Object e) {
        final Node l = last;
        final Node newNode = new Node(l, e, null);
        last = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
    }

    @Override
    public boolean addBefore(Object obj, Object e) {
        return false;
    }

    @Override
    public boolean addAfter(Object obj, Object e) {
        return false;
    }

    @Override
    public Object remove(int i) {
        return null;
    }

    @Override
    public boolean remove(Object e) {
        return false;
    }

    @Override
    public Object replace(int i, Object e) {
        return null;
    }

    @Override
    public Iterator iterator() {
        return null;
    }
    //双向链表的一个节点
    private static class Node {
        Object item;//该节点存储的数据
        Node next;//指向下一个节点
        Node prev;//指向前一个节点

        Node(Node prev, Object element, Node next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }
}

然后就是测试类

public class TestList {
    public static void main(String[] args) {
        //创建线性顺序表
        LinkedList list = new LinkedList();
        //向末尾添加元素
        list.add("11111");
        list.add("aaaaa");
        list.add("bbbbb");
        list.add("33333");
        list.add("22222");
        list.add(3, "AAAAA");
        //进行各种操作验证添加
        System.out.println(list.size());
        System.out.println(list.isEmpty());
        //System.out.println(list.toString());
        System.out.println(list.get(0));
    }
}