java的单向链表与双向链表

先说一下Linkedlist与ArrayList的比较:
Linkedlist是基于链表实现的,ArrayList是基于数组实现的,它们都不是线程安全的
Linkedlist和ArrayList相比查找比较慢,增删快,为什么?
    我们打个比方：LinkedList和ArrayList中都装了10个人。
    在ArrayList集合中的10个人是这样的：Arraylis由于是类似于数组它本身就有标号0，，,,2，3,，4........。每个人都站在一个标号上，比如我要找4号，我说4号出来，站在4号的人，一看自己的位置标号，就知道叫的是他，他就直接出来了，所以比较快。如果我要在4号位置加个人，那么从4号开始后面的的人都要往后移，把4号位置腾出来，所以比较麻烦。
    在LinkedList集合中的每个人都是随便站的。但是他们中的每个人都认识一个人。并且每两个认识的人之间都有一个链子把他们连接起来。所有人都连接完之后，顺着链子看，就也有一个顺序，每个人就也有一个序号，但是这个序号并没有标出来。也就是说相当于有一个隐式的序号。所以：比如我要叫4号出来的时候，他们并不知道自己到底谁是4号，所以就要顺着链子从头开始查一下，查到4号是谁了，4号就出来了。也就是说，每次要找n号位置的人时，都要从头查一遍，看谁是n号。所以查找比较麻烦。至于增删效率高，就很容易理解了。
    其实就是一点，就是相当于说：ArrayList集合中的索引是标示出来的，而LinkedList集合中的索引是隐式的只能一个接着一个的找，这样就很容易理解，为什么LinkedList集合中也有索引为什么查找效率就比Arraylist低的原因了。

单向与双向链表的实现:
通过Stack的后进后出或linkedList的默认新加删除实现单向链表,
通过linkedList的默认新加删除和它的addLast、removeFirst方法实现双向链表
    import java.util.Collections;
    import java.util.LinkedList;
    import java.util.List;
    import java.util.Stack;

    import org.junit.Before;

    public class T {
        public static LinkedList<String> dl;

        @Before
        public void init() {
            dl = new LinkedList<String>();
            dl.add("N1");
            dl.add("N2");
            dl.add("N3");
            dl.add("N4");
            dl.add("N5");
        }

        @org.junit.Test
        public void test() {
            for (String str : dl) {
                System.out.println("双向链表：" + str);
            }
        }

        @org.junit.Test
        public void add() {
            // 双向链表独有的向链表头部添加元素
            dl.addFirst("N6");
            dl.addLast("N7");

        }

        @org.junit.Test
        public void del() {
            dl.remove("N1");
            for (String str : dl) {
                System.out.println("双向链表：" + str);
            }
        }

        /**
         * 模仿栈的后进后出的pop
         * 
         * @return
         */
        public static String pop() {
            return dl.removeLast();
        }

        /**
         * 
         */
        @org.junit.Test
        public void stack() {
            System.out.println(T.pop());
            for (String str : dl) {
                System.out.println("双向链表：" + str);
            }
        }

        @org.junit.Test
        public void t() {
            Stack<String> statck = new Stack<String>();
            statck.push("N1");
            statck.push("N2");
            statck.push("N3");
            statck.push("N4");
            statck.push("N5");
            System.out.println("pop:" + statck.pop());
            for (String str : statck) {
                System.out.println(str);
            }
        }
        /**
         * 实现队列
         * 队列的数据元素又称为队列元素。在队列中插入一个队列元素称为入队，从队列中删除一个队列元素称为出队。因为队列只允许在一端插入，在另一端删除，
         * 所以只有最早进入队列的元素才能最先从队列中删除，故队列又称为先进先出（FIFO—first in first out）线性表。[1]
         * 队列队首删除 队尾插入
         */
        @org.junit.Test
        public void quene(){
            LinkedList<String> quene = new LinkedList<String>();
            quene = (LinkedList<String>)Collections.synchronizedCollection(quene);
            T.addQuene(quene, "n1");
            T.addQuene(quene, "n2");
            T.addQuene(quene, "n3");
            T.frecah(quene);
            System.out.println("---------------------------------");
            T.delQuene(quene);
            T.frecah(quene);
        }
        public static void frecah(List<String> list) {
            for(String str:list){
                System.out.println(str);
            }
        }
        /**
         * 每次插入都会插入队尾
         * @param quene
         * @param o
         */
        public static void addQuene(LinkedList<String> quene,String o){
            quene.add(o);
        }
        /**
         * 删除 从队首删除 
         */
        public static void delQuene(LinkedList<String> quene){
            quene.removeFirst();
        }
        

    }

 

参考:https://www.cnblogs.com/maoyali/p/8805975.html