11(1) LinkList ---链表

底层是由节点(静态内部类)来进行存储元素的，底层内存不连续，不需要扩容增删元素效率较高，查询元素效率较低 线程不安全

LinkedList类中有一个内部私有类Node，这个类就代表双端链表的节点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的实现中多次调用。

下图是LinkedList内部结构的可视化，能够帮我们更好的理解LinkedList内部的结构。

 

public class A {

    public static void main(String[] args) {
  ListLinked l=new ListLinked();
  l.add("hsdu");
  l.add("u");
  l.add("du");
  System.out.println(l);

    }

}
class ListLinked
{
    //元素个数/节点数
    int size=0;
    //头节点 -----表示第一个节点
    Node first;
    //尾部点------表示最后一个节点
    Node last;
    //节点-------内部类
    class Node
    {
        //存储的元素
        String item;
        //上一个节点
        Node prev;
        //下一个节点
        Node next;
        //有参构造
        public Node(String item,Node prev,Node next) //元素赋值
        {
            this.item=item;
            this.prev=prev;
            this.next=next;
        }
    }
    //添加
    public void add(String str)
    {
        //创建一个新节点
        Node node=new Node(str, null, null);
        //判断添加元素的位置
        if(size==0)//表明添加的是第一个节点
        {
            //头节点指向新节点
            this.first=node;
            //尾节点指向新节点
            this.last=node;
        }
        else //尾部节点
        {
            //原尾节点的last指向新节点
            this.last.next=node;
            //新节点的上一个指向原尾节点
            node.prev=this.last;
            //尾节点指向新节点
            this.last=node;
        }

        size++;
    }
    //插入
    public void insert(int index,String str) 
    {
        //判断下边是否越界
        if(index<0||index>size)
        {
            throw new IllegalArgumentException("index+"+index);
        }


        //判断插入节点的位置
        //插入的节点位置是头节点且size为0
        //在尾部进行添加节点
        if(index==size) {//尾部添加
            add(str);
            //结束方法保证size不会添加两次
            return;    
        }
        //新节点
        Node node=new Node(str, null, null);
        //判断插入头节点但是已经有了头节点
        //size 不为0
        if(index==0)
        {
            //原头节点的上一个指向新节点
            this.first.prev=node;
            //新节点的下一个指向原头节点
            node.next=this.first;
            //头节点指向新节点
            this.first=node;
        }
        else { //表明在中间插入
            //获取指定下标的节点
            Node no=this.first;
            for(int i=0;i<index;i++)
            {
                no=no.next; 
            }
            //最后会找到第index的节点no
            //插入在no之前
            no.prev.next=node; //no前面的节点的next指向新节点
            node.prev=no;      //新节点的next指向no
            no.prev=node; //no的prev指向新节点
            node.next=no; //新节点的next指向no
        }
        size++;
    }
    //下标越界问题
    public void out(int index)
    {
        //判断下边是否越界
        if(index<0||index>=size)
        {
            throw new IllegalArgumentException("index+"+index);
        }

    }
    //根据下标找到节点
    public Node getNode(int index)
    {
        Node n=this.first;
        for(int i=0;i<index;i++)
        {
            n=n.next;
        }
        return n;
    }
    //删除----根据下标
    public void remove(int index)
    {
        //下标越界问题
        out(index);
        //判断删除节点的位置
        if(index==0)
        {
            //头节点指向原头节点的下一个节点
            this.first=this.first.next;
            //原头节点的下一个节点的上一个为null
            this.first.prev=null;
        }
        else if(index==size-1) {//尾部节点删除
            //原尾节点的上一个节点的下一个为null
            this.last.prev.next=null;
            //尾节点指向原尾节点的上一个节点
            this.last=this.last.prev;
        }
        else {//删除中间节点
            //根据下标找到指定节点
            Node n=    getNode(index);
            //n节点的上一个节点的下一个指向no节点的下一个节点
            n.prev.next=n.next;
            n.next.prev=n.prev;

        }
        size--;
    }
    //根据指定元素进行删除
    public void remove(String str)
    {
        int i=indexOf(str);
        if(i!=-1)
        {
            remove(i);
        }
    }
    //找到元素第一次出现的坐标
    public int indexOf(String str) {
        //遍历节点找出满足要求的节点
        Node no=this.first;
        for(int i=0;i<size;i++)
        {
            //把每个节点的元素和参数作比较
            if(str==no.item||str!=null&&str.equals(no.item))
            {
                return i;

            }    
            no=no.next;
        }
        return -1;

    }
    @Override
    public String toString() {
        Node no=this.first;
        //创建对象
        StringBuilder sb=new StringBuilder("[");
        //拼接节点里的元素
        for(int i=0;i<size;i++)
        {    
            sb.append(no.item+", ");
            no=no.next;
        }
        String s=sb.toString();
        if(size>0)
        {
            s=s.substring(0, s.length()-2);
        }
        return s+"]";
    }
}

参考：https://www.jianshu.com/p/56c77c517e71