JDK1.8集合框架原始碼分析二-------------LinkedList

阿新 • • 發佈：2018-12-17

0.LinkedList特點

0.1) 刪除或新增效率高：不會移動資料元素，只會維護內部節點的關係

0.2) 查詢慢: 在其內部沒有下標，也即沒有索引，需要使用for迴圈遍歷,LInkedList為了提高效率，採用折半查詢演算法

1.LinkedList的成員屬性

1.1 int size --- LinkedList容器現有的節點個數

1.2 Node<E> first;--- 首節點，目的是為了查詢方便，從裡可以發起查詢

1.3 Node<E> last--- 尾節點，目的： (1) 從這裡新增元素 (2)也可以從這裡發起查詢

2.LinkedList的Node類的資料結構

    private static class Node<E>{
        E data;//節點資料
        Node<E> prev;//上一個節點
        Node<E> next;//下一個節點

        public Node(E data, Node<E> prev, Node<E> next) {
            this.data = data;
            this.prev = prev;
            this.next = next;
        }
    }

3.LinkedList的資料結構

4.LinkedList新增元素

    private void linkLast(E e) {
        //建立一個臨時變數儲存容器的尾節點
        final Node<E> l = last;
        //建立一個以當前容器尾節點為上一個節點，null為下一個節點的新節點
        final Node<E> newNode = new Node<E>(e, l, null);
        //把新節點賦值給尾節點
        last = newNode;
        //如果首節點為空
        if(first == null){
            first = newNode;
        }else{
            l.next = newNode;
        }
        size ++ ;
    }

    @Override
    public boolean add(E e) {
        linkLast(e);
        return true;
    }

5.LinkedList 指定下標index查詢元素

5.1) 陣列越界檢查 index >=0 && index < size

5.2) 根據當前容器所儲存的資料大小進行折半查詢

index < size >> 1 ====> index < size/2 從容器的首節點開始查詢

否則從容器的尾節點開始查詢

    @Override
    public E get(int index) {
        checkElementIndex(index);
        return node(index).data;
    }

    private void checkElementIndex(int index) {
        if (index >= 0 && index < size) {
            return;
        }
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    private Node<E> node(int index) {
        //即要想找到下標為index的節點，則只需要找到其相鄰節點即可得到該節點的資料
        Node<E> node = null;
        if(index < size >> 1){
            node = first;
            for (int i = 0; i < index; i ++){
                node = node.next;
            }
        }else{
            node = last;
            for (int i = (size -1); i > index; i --){
                node = node.prev;
            }
        }
        return node;
    }

6.LinkedList在指定下標index位置新增元素

6.1) 陣列下標越界檢查 index>=0 && index<=size

6.2) 找到下標所在的節點indexNode （index >=0 && index < size 只能找到這個範圍的節點）

6.3) 下標所在的節點為新節點newNode的下一個節點--->newNode.next = indexNode

6.4) 下標所在的節點的上一個節點indexOldPrevNode為新節點的上一個節點--->newNode.prev = indexOldPrevNode

6.4.1) 如果indexNode節點的上一個節點為null，則indexNode當前為first節點，此時需要更新首節點的內容

6.5）下標所在的節點的上一個節點的新值為新節點--->indexNode.prev = newNode

6.6 ) 當index = size時，直接在容器的末尾新增節點即可


    private void linkBefore(E e, Node<E> indexNode) {
        //下標所在的節點的上一個節點
        Node<E> prev = indexNode.prev;
        //利用建構函式建立新節點,
        //新節點的上一個節點為下標所在節點的上一個節點
        //新節點的下一個節點為下標所在的節點
        Node<E> newNode = new Node<>(e,prev,indexNode);
        //下標所在節點的新的上一個節點為新節點
        indexNode.prev = newNode;
        //如果下標所在節點的老的上一個節點為null
        //則說明下標所在節點在插入新的節點之前為首節點
        //現在插入新節點之後，新節點則稱為首節點
        if(prev == null){
            first = newNode;
        }else{
            //如果下標所在節點的老的上一個節點不為null
            //則說明下標所在的節點在插入新的節點之前不是首節點
            //則下標所在的節點的老的上一個節點的下一個節點為新節點
            prev.next = newNode;
        }
        size++;
    }

    @Override
    public boolean add(int index, E e) {
        checkElementIndexInPos(index);

        if (index == size){
            linkLast(e);
        }else{
            linkBefore(e,node(index));
        }
        return true;
    }

7.LinkedList指定下標刪除節點

7.1) 陣列越界檢查 index >=0 && index < size

7.2) 找出下標所在的節點 indexNode

7.3) indexNode.prev = oldIndexPrevNode; indexNode.next = oldIndexNextNode;

7.4) 如果 oldIndexPrevNode = null,則 first = indexNode ，即刪除的為首節點此時需要 first = oldIndexNextNode;

7.5) 如果 oldIndexPrevNode ！= null 則 oldIndexPrevNode.next = oldIndexNextNode;

7.6) 如果 oldIndexNextNode = null,則 last = indexNode,即刪除的是尾節點，需要last = oldIndexPrevNode;

7.7) 如果 oldIndexNextNode ！= null, 則oldIndexNextNode.prev = oldIndexPrevNode;

    private E unlink(Node<E> indexNode) {
        final E data = indexNode.data;
        final Node<E> oldIndexPrevNode = indexNode.prev;
        final Node<E> oldIndexNextNode = indexNode.next;

        if(oldIndexPrevNode == null){
            first = oldIndexNextNode;
        }else{
            oldIndexPrevNode.next = oldIndexNextNode;
            indexNode.prev = null;//GC回收
        }

        if(oldIndexNextNode == null){
            last = oldIndexPrevNode;
        }else{
            oldIndexNextNode.prev = oldIndexPrevNode;
            indexNode.next = null;//GC回收
        }
        indexNode.data = null;//GC回收
        size--;
        return data;
    }

    @Override
    public E remove(int index) {
        checkElementIndex(index);
        return unlink(node(index));
    }

8.LIinkedList指定元素值刪除

8.1) 找出指定元素所對應的節點

8.2) 根據節點刪除資料和步驟7一樣

    @Override
    public boolean remove(Object obj) {
        if(obj == null){
            //從首節點開始遍歷，找到複合條件的節點
            for(Node<E> x = first; x.next !=null; x = x.next){
                if(x.data == null){
                    unlink(x);
                    return true;
                }
            }
        }else{
            for(Node<E> x = first; x.next !=null; x = x.next){
                if(obj.equals(x.data)){
                    unlink(x);
                    return true;
                }
            }
        }
        return false;
    }

9.自己手寫LinkedList原始碼程式碼以及Junit測試類

package com.roger.collection.impl;

import com.roger.collection.RogerList;

public class RogerLinkedList<E> implements RogerList<E> {

    //容器中資料的大小
    private int size;
    //容器中首節點
    private Node<E> first;
    //容器中尾節點
    private Node<E> last;

    private void linkLast(E e) {
        //建立一個臨時變數儲存容器的尾節點
        final Node<E> l = last;
        //建立一個以當前容器尾節點為上一個節點，null為下一個節點的新節點
        final Node<E> newNode = new Node<E>(e, l, null);
        //把新節點賦值給尾節點
        last = newNode;
        //如果首節點為空
        if (first == null) {
            first = newNode;
        } else {
            l.next = newNode;
        }
        size++;
    }

    @Override
    public boolean add(E e) {
        linkLast(e);
        return true;
    }

    private void linkBefore(E e, Node<E> indexNode) {
        //下標所在的節點的上一個節點
        Node<E> prev = indexNode.prev;
        //利用建構函式建立新節點,
        //新節點的上一個節點為下標所在節點的上一個節點
        //新節點的下一個節點為下標所在的節點
        Node<E> newNode = new Node<>(e,prev,indexNode);
        //下標所在節點的新的上一個節點為新節點
        indexNode.prev = newNode;
        //如果下標所在節點的老的上一個節點為null
        //則說明下標所在節點在插入新的節點之前為首節點
        //現在插入新節點之後，新節點則稱為首節點
        if(prev == null){
            first = newNode;
        }else{
            //如果下標所在節點的老的上一個節點不為null
            //則說明下標所在的節點在插入新的節點之前不是首節點
            //則下標所在的節點的老的上一個節點的下一個節點為新節點
            prev.next = newNode;
        }
        size++;
    }

    @Override
    public boolean add(int index, E e) {
        checkElementIndexInPos(index);

        if (index == size){
            linkLast(e);
        }else{
            linkBefore(e,node(index));
        }
        return true;
    }

    private void checkElementIndexInPos(int index) {
        if (index >= 0 && index <= size) {
            return;
        }
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    @Override
    public E get(int index) {
        checkElementIndex(index);
        return node(index).data;
    }

    private void checkElementIndex(int index) {
        if (index >= 0 && index < size) {
            return;
        }
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    private Node<E> node(int index) {
        //即要想找到下標為index的節點，則只需要找到其相鄰節點即可得到該節點的資料
        Node<E> node = null;
        if(index < size >> 1){
            node = first;
            for (int i = 0; i < index; i ++){
                node = node.next;
            }
        }else{
            node = last;
            for (int i = (size -1); i > index; i --){
                node = node.prev;
            }
        }
        return node;
    }

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

    private E unlink(Node<E> indexNode) {
        final E data = indexNode.data;
        final Node<E> oldIndexPrevNode = indexNode.prev;
        final Node<E> oldIndexNextNode = indexNode.next;

        if(oldIndexPrevNode == null){
            first = oldIndexNextNode;
        }else{
            oldIndexPrevNode.next = oldIndexNextNode;
            indexNode.prev = null;//GC回收
        }

        if(oldIndexNextNode == null){
            last = oldIndexPrevNode;
        }else{
            oldIndexNextNode.prev = oldIndexPrevNode;
            indexNode.next = null;//GC回收
        }
        indexNode.data = null;//GC回收
        size--;
        return data;
    }

    @Override
    public E remove(int index) {
        checkElementIndex(index);
        return unlink(node(index));
    }


    @Override
    public boolean remove(Object obj) {
        if(obj == null){
            //從首節點開始遍歷，找到複合條件的節點
            for(Node<E> x = first; x.next !=null; x = x.next){
                if(x.data == null){
                    unlink(x);
                    return true;
                }
            }
        }else{
            for(Node<E> x = first; x.next !=null; x = x.next){
                if(obj.equals(x.data)){
                    unlink(x);
                    return true;
                }
            }
        }
        return false;
    }


    private static class Node<E> {
        E data;//節點資料
        Node<E> prev;//上一個節點
        Node<E> next;//下一個節點

        public Node(E data, Node<E> prev, Node<E> next) {
            this.data = data;
            this.prev = prev;
            this.next = next;
        }
    }

    private String outOfBoundsMsg(int index) {
        return "Index: " + index + ", Size: " + size;
    }
}

package com.roger.collection;

public interface RogerList<E> {

    boolean add(E e);

    boolean add(int index, E e);

    E get(int index);

    int size();

    E remove(int index);

    boolean remove(Object obj);
}

package com.roger.collection.impl;

import com.roger.collection.RogerList;
import org.junit.Test;

public class RogerLinkerListTest {

    @Test
    public void testAdd() {

        RogerList<String> rogerArrayList = new RogerLinkedList<>();
        rogerArrayList.add("Roger");
        rogerArrayList.add("Mary");
        rogerArrayList.add("Bruce");
        for (int i = 0; i < rogerArrayList.size(); i++) {
            System.out.println(rogerArrayList.get(i));
        }

    }

    @Test
    public void testAddByPos() {
        RogerList<String> rogerArrayList = new RogerArrayList<String>(1);
        rogerArrayList.add("Roger");
        rogerArrayList.add("Mary");
        rogerArrayList.add("Bruce");
        rogerArrayList.add(0, "Andy");
        for (int i = 0; i < rogerArrayList.size(); i++) {
            System.out.println(rogerArrayList.get(i));
        }
    }

    @Test
    public void testRemove(){
        RogerList<String> rogerArrayList = new RogerArrayList<String>(1);
        rogerArrayList.add("Roger");
        rogerArrayList.add("Mary");
        rogerArrayList.add("Bruce");
        rogerArrayList.add(3, "Andy");


        rogerArrayList.remove(3);
        rogerArrayList.add("Bruce1");
        for (int i = 0; i < rogerArrayList.size(); i++) {
            System.out.println(rogerArrayList.get(i));
        }
    }

    @Test
    public void testRemoveByObj(){
        RogerList<String> rogerArrayList = new RogerArrayList<String>(1);
        rogerArrayList.add("Roger");
        rogerArrayList.add("Mary");
        rogerArrayList.add(null);
        rogerArrayList.add("Bruce");
        rogerArrayList.add(3, "Andy");
        rogerArrayList.add(null);

        rogerArrayList.remove("Andy");
        rogerArrayList.remove(null);
        for (int i = 0; i < rogerArrayList.size(); i++) {
            System.out.println(rogerArrayList.get(i));
        }
    }
}

JDK1.8集合框架原始碼分析二-------------LinkedList

0.LinkedList特點 0.1) 刪除或新增效率高：不會移動資料元素，只會維護內部節點的關係 0.2) 查詢慢: 在其內部沒有下標，也即沒有索引，需要使用for迴圈遍歷,LInkedList為了提高效率，

JDK1.8集合框架原始碼分析一-------------ArrayList

1.ArrayList初始化 1.1 無參建構函式，預設一個空陣列 1.2 帶容量的有參建構函式：根據容量引數的值範圍來初始化 1.3 原始碼中陣列預設的初始容量

JDK1.8集合框架原始碼分析三-------------HashMap

1.HashMap的一些重要成員屬性 1.1) 預設的初始容量 DEFAULT_INITIAL_CAPACITY = 1 << 4，官方建議必須時2的次方數 1.2) 負載因子

Jdk1.8集合框架之HashMap原始碼解析（詳細解析紅黑樹）

HashMap特點不同步，支援null的鍵和值，put或get操作通常是常數時間。 Map介面的實現。去掉了Hashtable的contains(Object value)方法，保留containsKey和containsValue方法。使用

集合框架原始碼分析(jdK1.7)（十）集合框架對比總結

oracle java tutorial官方文件1.核心集合介面層次關係同類對比Map系列名稱特點資料結構初始容量（預設）擴容方式 HashMap 鍵值對，存Null值散列表 1

Java -- 基於JDK1.8的ArrayList原始碼分析

1，前言　　很久沒有寫部落格了，很想念大家，18年都快過完了，才開始寫第一篇，爭取後面每週寫點，權當是記錄，因為最近在看JDK的Collection，而且ArrayList原始碼這一塊也經常被面試官問道，所以今天也就和大家一起來總結一下 2，原始碼解讀　　當我們一般提到ArrayLi

通俗易懂的JDK1.8中HashMap原始碼分析（歡迎探討指正）+ 典型面試題

面試題在最下面說到HashMap之前，閱讀ArrayList與LinkedList的原始碼後做個總結 ArrayList 底層是陣列，查詢效率高，增刪效率低 LinkedList底層是雙鏈表，查詢效率低，增刪效率高這裡只是總結看完原始碼後對hashm

[jjzhu學java]之JDK集合框架原始碼分析

Java Collection 圖中實線邊框表示的是實現類（ArrayList, Hashtable等），虛線邊框的是抽象類（AbstractCollection，AbstractSequentialListd等），而點線邊框的是介面（Collect

圖解Java常用資料結構(一)＼JDK原始碼分析(二)——LinkedList

最近在整理資料結構方面的知識, 系統化看了下Java中常用資料結構, 突發奇想用動畫來繪製資料流轉過程. 主要基於jdk8, 可能會有些特性與jdk7之前不相同, 例如LinkedList LinkedHashMap中的雙向列表不再是迴環的. HashMap中的單鏈表

jdk1.8中hashtable原始碼分析

注：基於JDK 1.8.0_131原始碼為例進行分析 hashtable的結構圖 hashtable採用桶位+連結串列結構實現。 hashtable的實現採用的是“桶位”，即一個Entry陣列實現： Entry節點的實現：主要

【jdk1.8】String原始碼分析

String 類的宣告 public final class String implements java.io.Serializable, Comparable<String>, CharSequence 首先可以看到String

Java 集合框架原始碼分析-集合框架概述

集合框架介紹 Java集合工具包位於Java.util包下，包含了很多常用的資料結構，如陣列、連結串列、棧、佇列、集合、雜湊表等。學習Java集合框架下大致可以分為如下五個部分：List列表、Set集合、Map對映、迭代器（Iterator、Enumera

Java集合框架原始碼分析

在JDK的原始碼裡有一個RandomAccess介面，這個介面沒有任何方法需要實現，那麼它是幹什麼用的呢？ public interface RandomAccess { } 官方文件解釋如下: 介面RandomAccess被List實現用來指示它們支

MINA框架原始碼分析(二)

上一篇我們通過例項學習了MINA框架的用法，發現用起來還是挺方便的，就那麼幾步就可以了，本著學東西必知其原理的觀念，決定看看MINA的原始碼實現，好了，我們開始吧！ MINA原始碼對於客戶端和服務端來說基本上差別不是很大的，所以我計劃主要還是分析服務端的原始碼

Java集合框架原始碼分析(四)——LinkedHashMap

LinkedHashMap簡介 LinkedHashMap是HashMap的子類，與HashMap有著同樣的儲存結構，但它加入了一個雙向連結串列的頭結點，將所有put到LinkedHashmap的節點一一串成了一個雙向迴圈連結串列，因此它保留了節點插入的順序，

基於jdk1.8的HashMap原始碼分析（溫故學習）

鼎力推薦一下一. HashMap結構 HashMap在jdk1.6版本採用陣列+連結串列的儲存方式，但是到1.8版本時採用了陣列+連結串列/紅黑樹的方式進行儲存，有效的提高了查詢時間，解決衝突。這裡有一篇部落格寫的非常好，HashMap的結構圖也畫的非常清楚，鼎力推

集合框架原始碼學習之LinkedList

簡介 LinkedList是一個實現了List介面和Deque介面的雙端連結串列。 LinkedList底層的連結串列結構使它支援高效的插入和刪除操作，另外它實現了Deque介面，使得LinkedList類也具

JAVA常用集合原始碼分析：LinkedList

概述上一篇我們介紹了ArrayList,我們知道它的底層是基於陣列實現的，提到陣列，我們就馬上會想到它的兄弟連結串列，今天我們要介紹的LinkedList就是基於連結串列實現的。繼承結構 public class LinkedList<E> extends Abs

java集合原始碼分析(二)---ListIterator與Iterator

吐槽早上起來刷牙洗臉洗頭髮後，正準備去上課，然後發現今天早上好像不上課emmmmmm，然後就早上繼續看下java集合方面的原始碼了吼吼吼 Iterator 上次好像說過一點這個，然後繼續複習下這個還是先看下官方文件然後我們發現這個東西就是個功能很少但很

JAVA常用集合框架原始碼解析（基於1.8）開題篇

倪升武的部落格中有一個小專題，讀完之後，發現博主的分析基本是基於JAVA1.7的，這裡我基於JAVA1.8給出一些新的解讀。但是對於JAVA1.8新增的一些新特性可能不太會作過多的分析（畢竟本人目前水平有限，且本部落格的寫作初衷也是以基礎學習為主），在徹底淺讀完

JDK1.8集合框架原始碼分析二-------------LinkedList

0.LinkedList特點

1.LinkedList的成員屬性

2.LinkedList的Node類的資料結構

3.LinkedList的資料結構

4.LinkedList新增元素

5.LinkedList 指定下標index查詢元素

6.LinkedList在指定下標index位置新增元素

7.LinkedList指定下標刪除節點

8.LIinkedList指定元素值刪除

9.自己手寫LinkedList原始碼程式碼以及Junit測試類

相關推薦