(二)LinkedList集合解析及手寫集合

一、LinkedList集合特點

問題	結      論
LinkedList是否允許空	允許
LinkedList是否允許重復數據	允許
LinkedList是否有序	有序
LinkedList是否線程安全	非線程安全

　　 LinkedList集合底層是由雙向鏈表組成，而不是雙向循環鏈表。

 有一個頭結點和一個尾結點，我們可以從頭開始正向遍歷，或者是從尾開始逆向遍歷，並且可以針對頭部和尾部進行相應的操作。

二、LinkedList集合底層實現

1.什么是鏈表

       鏈表原是一種線性的存儲結構，意思是將要存儲的數據存在一個存儲單元里面，這個存儲單元里面除了存放有待存儲的數據以外，還存儲有其下一個存儲單元的地址（下一個存儲單元的地址是必要的，有些存儲結構還存放有其前一個存儲單元的地址），每次查找數據的時候，通過某個存儲單元中的下一個存儲單元的地址尋找其后面的那個存儲單元。

2. 什么是雙向鏈表 

 雙向鏈表也是鏈表的一種，它每個數據結點中都有兩個結點，分別指向其直接前驅和直接后繼。所以我們從雙向鏈表的任意一個結點開始都可以很方便的訪問其前驅元素和后繼元素。

3.雙向鏈表的定義

雙向鏈表也是鏈表的一種，它每個數據結點中都有兩個結點，分別指向其直接前驅和直接后繼。所以我們從雙向鏈表的任意一個結點開始都可以很方便的訪問其前驅元素和后繼元素。

4.雙向鏈表的存儲結構

  雙向鏈表也是采用的鏈式存儲結構，它與單鏈表的區別就是每個數據結點中多了一個指向前驅元素的指針域 ，它的存儲結構如下圖

當雙向鏈表只有一個結點的時候它的存儲結構如下：

 頭節點和尾結點指向同一個元素。

 三.LinkedList源碼分析

1.構造方法，無參構造，有參構造。

public LinkedList() {
}
public LinkedList(Collection<? extends E> c) {
        // 調用無參構造函數
        this();
        // 添加集合中所有的元素
        addAll(c);
    }

2.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;
        }
    }

 

3.添加元素 add方法

public boolean add(E e) {
        linkLast(e);// // 添加元素到末尾
        return true;
    }
void linkLast(E e) {
        // 保存尾結點，l為final類型，不可更改
        final Node<E> l = last;
        // 新生成結點的前驅為l,后繼為null
        final Node<E> newNode = new Node<>(l, e, null);
        // 重新賦值尾結點
        last = newNode;    
        if (l == null) // 尾結點為空
            first = newNode; // 賦值頭結點
        else // 尾結點不為空
            l.next = newNode; // 尾結點的后繼為新生成的結點
        // 大小加1    
        size++;
        // 結構性修改加1
        modCount++;
    }

 3.查詢元素E get(int index)獲取指定節點數據

public E get(int index) {
    checkElementIndex(index);
    return node(index).item;
}
 Node<E> node(int 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; // 返回該結點
        }
    }

 4.remove移除結點時

E unlink(Node<E> x) {
        // 保存結點的元素
        final E element = x.item;
        // 保存x的后繼
        final Node<E> next = x.next;
        // 保存x的前驅
        final Node<E> prev = x.prev;
        
        if (prev == null) { // 前驅為空，表示刪除的結點為頭結點
            first = next; // 重新賦值頭結點
        } else { // 刪除的結點不為頭結點
            prev.next = next; // 賦值前驅結點的后繼
            x.prev = null; // 結點的前驅為空，切斷結點的前驅指針
        }

        if (next == null) { // 后繼為空，表示刪除的結點為尾結點
            last = prev; // 重新賦值尾結點
        } else { // 刪除的結點不為尾結點
            next.prev = prev; // 賦值后繼結點的前驅
            x.next = null; // 結點的后繼為空，切斷結點的后繼指針
        }

        x.item = null; // 結點元素賦值為空
        // 減少元素實際個數
        size--; 
        // 結構性修改加1
        modCount++;
        // 返回結點的舊元素
        return element;
    }

 四.手寫LinkedList代碼：

手寫源碼主要是為了便於對LinkedList集合的更好理解，主要對add(),remove,add(index,element) ,get(i)這些方法進行簡單的寫法，寫法比較通俗更便於理解。具體可以參考下面的代碼。

1.自定義LinkedList集合。

package com.zzw.cn.springmvc.linkList;

/**
 * @author Simple
 * @date 16:58 2019/9/5
 * @description 手寫LinkList集合
 * 思路:
 * 1.集合add
 * 2.remove
 * 3.add(index,element)
 */

public class AnLinkeList<E> {
    private Node first;//第一個節點值
    private Node last;//最后一個節點值
    int size;//集合長度

    /**
     * 添加
     *
     * @param e
     */
    public void add(E e) {
        Node node = new Node();
        //增加時判斷集合是否為null 1.為null時候位置指向不同
        node.object = e;
        if (null == first) {

            //第一個元素添加是第一個節點和最后一個節點指向位置都為第一個
            first = node;
        } else {
            //存放上一個節點內容
            node.prev = last;
            //將上一個節點值指向當前節點
            last.next = node;
        }
        //對最后一個節點賦值
        last = node;
        size++;
    }

    public E get(int index) {
        Node node = null;
        if (null != first) {
            node = first;
            //循環遍歷指向最后一個節點
            for (int i = 0; i < index; i++) {
                node = node.next;
            }
            return (E) node.object;
        }
        return null;
    }

    public Node getNode(int index) {
        Node node = null;
        if (null != first) {
            node = first;
            //循環遍歷指向最后一個節點
            for (int i = 0; i < index; i++) {
                node = node.next;
            }
            return node;
        }
        return null;
    }

    //刪除
    public void remove(int index) {
        //1找到當前元素  刪除時，將當前元素B的pre指向上一個A節點，將上一個元素A的節點指向當前元素B的next節點。
        checkElementIndex(index);
        Node node = getNode(index);
        Node prevNode = node.prev;
        Node nextNode = node.next;
        if (prevNode.next != null) {
            prevNode.next = nextNode;
        }
        if (nextNode != null) {
            nextNode.prev = prevNode;
        }
        size--;

    }

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

    private void checkElementIndex(int index) {
        if (!isElementIndex(index))
            throw new IndexOutOfBoundsException("越界啦!");
    }

    private void add(int index, E e) {
        checkElementIndex(index);
        if (index == size)
            add(e);
        else
            addEle(index, e);

    }

    private void addEle(int index, E e) {
        /**
         *
         *   新增E  上一個節點是A   下一個節點是B
         *   A->next=E
         *   E->pre=A
         *   E->next=B
         *   B->pre=E
         */
        Node newNode = new Node();
        newNode.object = e;
        Node oldNode = getNode(index);
        Node oldPrev = oldNode.prev;
        //當前節點上一個對應新節點
        oldNode.prev = newNode;
        //如果當前節點為第一個時候
        if (oldPrev == null) {
            first = newNode;
        } else {
            //新節點的下一個對應當前節點
            oldPrev.next = newNode;
        }
        //新節點的上一個對應老節點之前的
        newNode.prev = oldPrev;
        //老節點的下一個對應新節點
        newNode.next = oldNode;
        size++;

    }

}

 2.節點的定義

package com.zzw.cn.springmvc.linkList;

/**
 * @author Simple
 * @date 17:01 2019/9/5
 * @description 定義節點
 */
public class Node {
    Node prev;//上一個節點
    Node next;//下一個節點
    Object object;//節點值
}

 3.測試類的編寫。

package com.zzw.cn.springmvc.linkList;

/**
 * @author Simple
 * @date 19:45 2019/9/5
 * @description
 */
public class TestLinkeList {
    public static void main(String[] args) {
        AnLinkeList<String> list = new AnLinkeList<>();
        list.add("1");
        list.add("2");
        list.add("3");
        System.out.println("add方法后結果");
        for (int i = 0; i < list.size; i++) {
            System.out.print(list.get(i)+" ");
        }
        System.out.println();
        list.remove(2);
        System.out.println("remove方法后結果");
        for (int i = 0; i < list.size; i++) {
            System.out.print(list.get(i)+" ");
        }
        System.out.println("根據索引值添加的");
        list.add(1,"3");
        for (int i = 0; i < list.size; i++) {
            System.out.print(list.get(i)+" ");
        }
    }
}

 4.運行結果

 五、LinkedList和ArrayList的對比

1、順序插入速度ArrayList會比較快，因為ArrayList是基於數組實現的，數組是事先new好的，只要往指定位置塞一個數據就好了；

     LinkedList則不同，每次順序插入的時候LinkedList將new一個對象出來，如果對象比較大，那么new的時間勢必會長一點，再加上一些引用賦值的操作，所以順序插入LinkedList必然慢於ArrayList

2、基於上一點，因為LinkedList里面不僅維護了待插入的元素，還維護了Entry的前置Entry和后繼Entry，如果一個LinkedList中的Entry非常多，那么LinkedList將比ArrayList更耗費一些內存

3、有些說法認為LinkedList做插入和刪除更快，這種說法其實是不准確的：

（1）LinkedList做插入、刪除的時候，慢在尋址，快在只需要改變前后Entry的引用地址

（2）ArrayList做插入、刪除的時候，慢在數組元素的批量copy，快在尋址