Java中List集合介紹（炒雞詳細呦）

Java中List集合介紹

1，Java集合介紹

作爲一個程序猿，Java集合類可以說是我們在工作中運用最多、最頻繁的類。相比於數組（Array）來說，集合類的長度可變，更加方便開發。

Java集合就像一個容器，可以存儲任何類型的數據，也可以結合泛型來存儲具體的類型對象。在程序運行時，Java集合可以動態的進行擴展，隨着元素的增加而擴大。在Java中，集合類通常存在於java.util包中。

Java集合主要由2大體系構成，分別是Collection體系和Map體系，其中Collection和Map分別是2大體系中的頂層接口。

Collection主要有三個子接口，分別爲List(列表)、Set(集)、Queue(隊列)。其中，List、Queue中的元素有序可重複，而Set中的元素無序不可重複。

List中主要有ArrayList、LinkedList兩個實現類；Set中則是有HashSet實現類；而Queue是在JDK1.5後纔出現的新集合，主要以數組和鏈表兩種形式存在。

Map同屬於java.util包中，是集合的一部分，但與Collection是相互獨立的，沒有任何關係。Map中都是以key-value的形式存在，其中key必須唯一，主要有HashMap、HashTable、treeMap三個實現類。

2，List介紹

在Collection中，List集合是有序的，可對其中每個元素的插入位置進行精確地控制，可以通過索引來訪問元素，遍歷元素。

在List集合中，我們常用到ArrayList和LinkedList這兩個類。

2.1 ArrayList集合

1，ArrayList底層通過數組實現，隨着元素的增加而動態擴容。

2，ArrayList是Java集合框架中使用最多的一個類，是一個數組隊列，線程不安全集合。

它繼承於AbstractList，實現了List, RandomAccess, Cloneable, Serializable接口。

1，ArrayList實現List，得到了List集合框架基礎功能；
2，ArrayList實現RandomAccess，獲得了快速隨機訪問存儲元素的功能，RandomAccess是一個標記接口，沒有任何方法；
3，ArrayList實現Cloneable，得到了clone()方法，可以實現克隆功能；
4，ArrayList實現Serializable，表示可以被序列化，通過序列化去傳輸，典型的應用就是hessian協議。

ArrayList集合的特點：

• 容量不固定，隨着容量的增加而動態擴容（閾值基本不會達到）
• 有序集合（插入的順序==輸出的順序）
• 插入的元素可以爲null
• 增刪改查效率更高（相對於LinkedList來說）
• 線程不安全

ArrayList的底層數據結構：

2.2 LinkedList集合

1，LinkedList底層通過鏈表來實現，隨着元素的增加不斷向鏈表的後端增加節點。

2，LinkedList是一個雙向鏈表，每一個節點都擁有指向前後節點的引用。相比於ArrayList來說，LinkedList的隨機訪問效率更低。

它繼承AbstractSequentialList，實現了List, Deque, Cloneable, Serializable接口。

1，LinkedList實現List，得到了List集合框架基礎功能；
2，LinkedList實現Deque，Deque 是一個雙向隊列，也就是既可以先入先出，又可以先入後出，說簡單點就是既可以在頭部添加元素，也可以在尾部添加元素；
3，LinkedList實現Cloneable，得到了clone()方法，可以實現克隆功能；
4，LinkedList實現Serializable，表示可以被序列化，通過序列化去傳輸，典型的應用就是hessian協議。

LinkedList集合的底層數據結構：

3，List常用方法

A:添加功能
boolean add(E e):向集合中添加一個元素
void add(int index, E element):在指定位置添加元素
boolean addAll(Collection<? extends E> c)：向集合中添加一個集合的元素。

B:刪除功能
void clear()：刪除集合中的所有元素
E remove(int index)：根據指定索引刪除元素，並把刪除的元素返回
boolean remove(Object o)：從集合中刪除指定的元素
boolean removeAll(Collection<?> c):從集合中刪除一個指定的集合元素。

C:修改功能
E set(int index, E element):把指定索引位置的元素修改爲指定的值，返回修改前的值。

D:獲取功能
E get(int index)：獲取指定位置的元素
Iterator iterator():就是用來獲取集合中每一個元素。

E:判斷功能
boolean isEmpty()：判斷集合是否爲空。
boolean contains(Object o)：判斷集合中是否存在指定的元素。
boolean containsAll(Collection<?> c)：判斷集合中是否存在指定的一個集合中的元素。

F:長度功能
int size():獲取集合中的元素個數

G:把集合轉換成數組
Object[] toArray():把集合變成數組。

3.1 ArrayList 基本操作

public class ArrayListTest {
    public static void main(String[] agrs){
        //創建ArrayList集合：
        List<String> list = new ArrayList<String>();
        System.out.println("ArrayList集合初始化容量："+list.size());
		// ArrayList集合初始化容量：0
        
        //添加功能：
        list.add("Hello");
        list.add("world");
        list.add(2,"!");
        System.out.println("ArrayList當前容量："+list.size());
        // ArrayList當前容量：3

        //修改功能：
        list.set(0,"my");
        list.set(1,"name");
        System.out.println("ArrayList當前內容："+list.toString());
        // ArrayList當前內容：[my, name, !]

        //獲取功能：
        String element = list.get(0);
        System.out.println(element);
        // my

        //迭代器遍歷集合：(ArrayList實際的跌倒器是Itr對象)
        Iterator<String> iterator =  list.iterator();
        while(iterator.hasNext()){
            String next = iterator.next();
            System.out.println(next);
        }
        /**  
        	my
            name
            !
        */

        //for循環迭代集合：
        for(String str:list){
            System.out.println(str);
        }
        /**  
        	my
            name
            !
        */

        //判斷功能：
        boolean isEmpty = list.isEmpty();
        boolean isContain = list.contains("my");

        //長度功能：
        int size = list.size();

        //把集合轉換成數組：
        String[] strArray = list.toArray(new String[]{});

        //刪除功能：
        list.remove(0);
        list.remove("world");
        list.clear();
        System.out.println("ArrayList當前容量："+list.size());
        // ArrayList當前容量：0
    }
}

3.2 LinkedList 基本操作

public class LinkedListTest {
    public static void main(String[] agrs){
        List<String> linkedList = new LinkedList<String>();
        System.out.println("LinkedList初始容量："+linkedList.size());
        // LinkedList初始容量：0

        //添加功能：
        linkedList.add("my");
        linkedList.add("name");
        linkedList.add("is");
        linkedList.add("jiaboyan");
        System.out.println("LinkedList當前容量："+ linkedList.size());
        // LinkedList當前容量：4

        //修改功能:
        linkedList.set(0,"hello");
        linkedList.set(1,"world");
        System.out.println("LinkedList當前內容："+ linkedList.toString());
        // LinkedList當前內容：[hello, world, is, jiaboyan]

        //獲取功能：
        String element = linkedList.get(0);
        System.out.println(element);
        // hello

        //遍歷集合：(LinkedList實際的迭代器是ListItr對象)
        Iterator<String> iterator =  linkedList.iterator();
        while(iterator.hasNext()){
            String next = iterator.next();
            System.out.println(next);
        }
        /**
        	hello
            world
            is
            jiaboyan
        */
        
        //for循環迭代集合：
        for(String str:linkedList){
            System.out.println(str);
        }
        /**
        	hello
            world
            is
            jiaboyan
        */

        //判斷功能：
        boolean isEmpty = linkedList.isEmpty();
        boolean isContains = linkedList.contains("jiaboyan");

        //長度功能：
        int size = linkedList.size();

        //刪除功能：
        linkedList.remove(0);
        linkedList.remove("jiaboyan");
        linkedList.clear();
        System.out.println("LinkedList當前容量：" + linkedList.size());
        // LinkedList當前容量：0
    }
}

4，ArrayList和LinkedList比較

（1）元素新增性能比較

網上很多說的是，在做新增操作時，ArrayList的效率遠不如LinkedList，因爲Arraylist底層時數組實現的，在動態擴容時，性能會有所損耗，而LinkedList不存在數組擴容機制，所以LinkedList的新增性能較好。究竟時哪個好呢，我們用實踐得到結果。

public class ListTest{
    // 迭代次數
    public static int ITERATION_NUM = 100000;

    public static void main(String[] args) {
        try{
            insertPerformanceCompare();
        }catch (Exception e){}
    }

    //新增性能比較：
    public static void insertPerformanceCompare() throws InterruptedException {
        Thread.sleep(5000);

        System.out.println("LinkedList新增測試開始");
        long start = System.nanoTime();
        List<Integer> linkedList = new LinkedList<Integer>();
        for (int x = 0; x < ITERATION_NUM; x++) {
            linkedList.add(x);
        }
        long end = System.nanoTime();
        System.out.println(end - start);

        System.out.println("ArrayList新增測試開始");
        start = System.nanoTime();
        List<Integer> arrayList = new ArrayList<Integer>();
        for (int x = 0; x < ITERATION_NUM; x++) {
            arrayList.add(x);
        }
        end = System.nanoTime();
        System.out.println(end - start);
    }
}

測試結果：

第一次：
    LinkedList新增測試開始
    10873720
    ArrayList新增測試開始
    5535277
第二次：
	LinkedList新增測試開始
    13097503
    ArrayList新增測試開始
    6046139
第三次：
	LinkedList新增測試開始
    12004669
    ArrayList新增測試開始
    6509783

結果與預想的有些不太一樣，ArrayList的新增性能並不低。

原因：

​ 可能是經過JDK近幾年的更新發展，對於數組複製的實現進行了優化，以至於ArrayList的性能也得到了提高。

（2）元素獲取比較

由於LinkedList是鏈表結構，沒有角標的概念，沒有實現RandomAccess接口，不具備隨機元素訪問功能，所以在get方面表現的差強人意，ArrayList再一次完勝。

public class ListTest {
    //迭代次數，集合大小：
    public static int ITERATION_NUM = 100000;

    public static void main(String[] agrs) {
       try{
            getPerformanceCompare();
        }catch (Exception e){}
    }

    //獲取性能比較：
    public static void getPerformanceCompare()throws InterruptedException {
        Thread.sleep(5000);

        //填充ArrayList集合：
        List<Integer> arrayList = new ArrayList<Integer>();
        for (int x = 0; x < ITERATION_NUM; x++) {
            arrayList.add(x);
        }

        //填充LinkedList集合：
        List<Integer> linkedList = new LinkedList<Integer>();
        for (int x = 0; x < ITERATION_NUM; x++) {
            linkedList.add(x);
        }

        //創建隨機數對象：
        Random random = new Random();

        System.out.println("LinkedList獲取測試開始");
        long start = System.nanoTime();
        for (int x = 0; x < ITERATION_NUM; x++) {
            int j = random.nextInt(x + 1);
            int k = linkedList.get(j);
        }
        long end = System.nanoTime();
        System.out.println(end - start);

        System.out.println("ArrayList獲取測試開始");
        start = System.nanoTime();
        for (int x = 0; x < ITERATION_NUM; x++) {
            int j = random.nextInt(x + 1);
            int k = arrayList.get(j);
        }
        end = System.nanoTime();
        System.out.println(end - start);
    }
}

測試結果：

第一次：
    LinkedList獲取測試開始
    8190063123
    ArrayList獲取測試開始
    8590205
第二次：
	LinkedList獲取測試開始
    8100623160
    ArrayList獲取測試開始
    11948919
第三次：
	LinkedList獲取測試開始
    8237722833
    ArrayList獲取測試開始
    6333427

從結果可以看出，ArrayList在隨機訪問方面表現的十分優秀，比LinkedList強了很多。

原因：

​ 這主要是LinkedList的代碼實現所致，每一次獲取都是從頭開始遍歷，一個個節點去查找，每查找一次就遍歷一次，所以性能自然得不到提升。

5，ArrayList源碼分析

接下來，我們對ArrayList集合進行源碼分析，其中先來幾個問題：

（1）ArrayList的構造

（2）增刪改查的實現

（3）迭代器——modCount

（4）爲什麼數組對象要使用transient修飾符

（5）System.arraycopy()參數含義 Arrays.copyOf()參數含義

我們通過上面幾個問題，對ArrayList的源碼進行一步一步的解析。

ArrayList構造器

1，在JDK1.7版本中，ArrayList的無參構造方法並沒有生成容量爲10的數組。

2，elementData對象是ArrayList集合底層保存元素的實現。

3，size屬性記錄了ArrayList集合中實際元素的個數。

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable {

    //實現Serializable接口，生成的序列版本號：
    private static final long serialVersionUID = 8683452581122892189L;

    //ArrayList初始容量大小：在無參構造中不使用了
    private static final int DEFAULT_CAPACITY = 10;

    //空數組對象：初始化中默認賦值給elementData
    private static final Object[] EMPTY_ELEMENTDATA = {};

    //ArrayList中實際存儲元素的數組：
    private transient Object[] elementData;

    //集合實際存儲元素長度：
    private int size;

    //ArrayList有參構造：容量大小
    public ArrayList(int initialCapacity) {
        //即父類構造：protected AbstractList() {}空方法
        super();
        //如果傳遞的初始容量小於0 ，拋出異常
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
        //初始化數據：創建Object數組
        this.elementData = new Object[initialCapacity];
    }

    //ArrayList無參構造：
    public ArrayList() {
        //即父類構造：protected AbstractList() {}空方法
        super();
        //初始化數組：空數組，容量爲0
        this.elementData = EMPTY_ELEMENTDATA;
    }

    //ArrayList有參構造：Java集合
    public ArrayList(Collection<? extends E> c) {
        //將集合轉換爲數組：
        elementData = c.toArray();
        //設置數組的長度：
        size = elementData.length;
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    }
}

add() 添加

1，在JDK1.7當中，當第一個元素添加時，ensureCapacityInternal()方法會計算ArrayList的擴容大小，默認爲10。

2，其中grow()方法最爲重要，如果需要擴容，那麼擴容後的大小是原來的1.5倍，實際上最終調用了Arrays.copyOf()方法得以實現。

//添加元素e
public boolean add(E e) {
    ensureCapacityInternal(size + 1);
    //將對應角標下的元素賦值爲e：
    elementData[size++] = e;
    return true;
}
//得到最小擴容量
private void ensureCapacityInternal(int minCapacity) {
    //如果此時ArrayList是空數組,則將最小擴容大小設置爲10：
    if (elementData == EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    //判斷是否需要擴容：
    ensureExplicitCapacity(minCapacity);
}
//判斷是否需要擴容
private void ensureExplicitCapacity(int minCapacity) {
    //操作數+1
    modCount++;
    //判斷最小擴容容量-數組大小是否大於0：
    if (minCapacity - elementData.length > 0)
        //擴容：
        grow(minCapacity);
}
//ArrayList動態擴容的核心方法:
private void grow(int minCapacity) {
    //獲取現有數組大小：
    int oldCapacity = elementData.length;
    //位運算，得到新的數組容量大小，爲原有的1.5倍：
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    //如果新擴容的大小依舊小於傳入的容量值，那麼將傳入的值設爲新容器大小：
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;

    //如果新容器大小，大於ArrayList最大長度：
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        //計算出最大容量值：
        newCapacity = hugeCapacity(minCapacity);
    //數組複製：
    elementData = Arrays.copyOf(elementData, newCapacity);
}
// 計算ArrayList最大容量：
private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0)
        throw new OutOfMemoryError();
    //如果新的容量大於MAX_ARRAY_SIZE。將會調用hugeCapacity將int的最大值賦給newCapacity:
    return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
}

remove() 刪除

1，remove(int index)是針對於角標來進行刪除，不需要去遍歷整個集合，效率更高。

2，而remove(Object o)是針對於對象來進行刪除，需要遍歷整個集合進行equals()方法比對，所以效率較低。

3，不過，無論是哪種形式的刪除，最終都會調用System.arraycopy()方法進行數組複製操作，所以效率都會受到影響。

//在ArrayList的移除index位置的元素
public E remove(int index) {
    //檢查角標是否合法：不合法拋異常
    rangeCheck(index);
    //操作數+1：
    modCount++;
    //獲取當前角標的value:
    E oldValue = elementData(index);
    //獲取需要刪除元素 到最後一個元素的長度，也就是刪除元素後，後續元素移動的個數；
    int numMoved = size - index - 1;
    //如果移動元素個數大於0 ，也就是說刪除的不是最後一個元素：
    if (numMoved > 0)
        // 將elementData數組index+1位置開始拷貝到elementData從index開始的空間
        System.arraycopy(elementData, index+1, elementData, index, numMoved);
    //size減1，並將最後一個元素置爲null
    elementData[--size] = null;
    //返回被刪除的元素：
    return oldValue;
}

//在ArrayList的移除對象爲O的元素，不返回被刪除的元素：
public boolean remove(Object o) {
    //如果o==null，則遍歷集合，判斷哪個元素爲null：
    if (o == null) {
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
                //快速刪除，和前面的remove（index）一樣的邏輯
                fastRemove(index);
                return true;
            }
    } else {
        //同理：
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}

//快速刪除：
private void fastRemove(int index) {
    //操作數+1
    modCount++;
    //獲取需要刪除元素 到最後一個元素的長度，也就是刪除元素後，後續元素移動的個數；
    int numMoved = size - index - 1;
    //如果移動元素個數大於0 ，也就是說刪除的不是最後一個元素：
    if (numMoved > 0)
        // 將elementData數組index+1位置開始拷貝到elementData從index開始的空間
        System.arraycopy(elementData, index+1, elementData, index, numMoved);
    //size減1，並將最後一個元素置爲null
    elementData[--size] = null;
}

set() 修改

由於ArrayList實現了RandomAccess，所以具備了隨機訪問特性，調用elementData()可以獲取到對應元素的值。

//設置index位置的元素值了element，返回該位置的之前的值
public E set(int index, E element) {
    //檢查index是否合法：判斷index是否大於size
    rangeCheck(index);
    //獲取該index原來的元素：
    E oldValue = elementData(index);
    //替換成新的元素：
    elementData[index] = element;
    //返回舊的元素：
    return oldValue;
}

get() 獲取元素

通過elementData()方法獲取對應角標元素，在返回時候進行類型轉換。

//獲取index位置的元素
public E get(int index) {
    //檢查index是否合法：
    rangeCheck(index);
    //獲取元素：
    return elementData(index);
}
//獲取數組index位置的元素：返回時類型轉換
E elementData(int index) {
    return (E) elementData[index];
}

modCount含義

1，在Itr迭代器初始化時,將ArrayList的modCount屬性的值賦值給了expectedModCount。

2，通過上面的例子中，我們可以知道當進行增刪改時，modCount會隨着每一次的操作而+1，modCount記錄了ArrayList內發生改變的次數。

3，當迭代器在迭代時，會判斷expectedModCount的值是否還與modCount的值保持一致，如果不一致則拋出異常。

AbstractList類當中定義的變量：

protected transient int modCount = 0;

ArrayList獲取迭代器對象：

//返回一個Iterator對象，Itr爲ArrayList的一個內部類，其實現了Iterator<E>接口
public Iterator<E> iterator() {
    return new java.util.ArrayList.Itr();
}

迭代器實現：

//Itr實現了Iterator接口，是ArrayList集合的迭代器對象
private class Itr implements Iterator<E> {
    //類似遊標，指向迭代器下一個值的位置
    int cursor; 

    //迭代器最後一次取出的元素的位置。
    int lastRet = -1; 

    //Itr初始化時候ArrayList的modCount的值。
    int expectedModCount = modCount;

    //利用遊標，與size之前的比較，判斷迭代器是否還有下一個元素
    public boolean hasNext() {
        return cursor != size;
    }

    //迭代器獲取下一個元素：
    public E next() {
        //檢查modCount是否改變：
        checkForComodification();
        int i = cursor;
        //遊標不會大於等於集合的長度：
        if (i >= size)
            throw new NoSuchElementException();
        Object[] elementData = java.util.ArrayList.this.elementData;
        //遊標不會大於集合中數組的長度：
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        //遊標+1
        cursor = i + 1;
        //取出元素：
        return (E) elementData[lastRet = i];
    }

    public void remove() {
        if (lastRet < 0)
            throw new IllegalStateException();
        //檢查modCount是否改變：防止併發操作集合
        checkForComodification();
        try {
            //刪除這個元素：
            java.util.ArrayList.this.remove(lastRet);
            //刪除後，重置遊標，和當前指向元素的角標 lastRet
            cursor = lastRet;
            lastRet = -1;
            //重置expectedModCount：
            expectedModCount = modCount;
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }

    //併發檢查：
    final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }
}

transient 修飾符

1，當我們序列化對象時，如果對象中某個屬性不進行序列化操作，那麼在該屬性前添加transient修飾符即可實現。例如：

private transient Object[] elementData;

那麼問題來了，爲什麼ArrayList不想對elementData屬性進行序列化呢？elementData可是集合中保存元素的數組啊，如果不序列化elementData屬性，那麼在反序列化時候，豈不是丟失了原先的元素？

原因是 ArrayList在添加元素時，可能會對elementData數組進行擴容操作，而擴容後的數組可能並沒有全部保存元素。

例如：我們創建了new Object[10]數組對象，但是我們只向其中添加了1個元素，而剩餘的9個位置並沒有添加元素。當我們進行序列化時，並不會只序列化其中一個元素，而是將整個數組進行序列化操作，那些沒有被元素填充的位置也進行了序列化操作，間接的浪費了磁盤的空間，以及程序的性能。

所以，ArrayList纔會在elementData屬性前加上transient修飾符。

接下來，我們來看下ArrayList的writeObject()、readObject()

//序列化寫入：
private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException{
    int expectedModCount = modCount;
    s.defaultWriteObject();
    s.writeInt(size);
    for (int i=0; i<size; i++) {
        s.writeObject(elementData[i]);
    }
    if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
    }
}

// 序列化讀取：
private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException {
    elementData = EMPTY_ELEMENTDATA;
    s.defaultReadObject();
    s.readInt();
    if (size > 0) {
        ensureCapacityInternal(size);
        Object[] a = elementData;
        for (int i=0; i<size; i++) {
            a[i] = s.readObject();
        }
    }
}

1，ArrayList在序列化時會調用writeObject()，直接將elementData寫入ObjectOutputStream。

2，反序列化時則調用readObject()，從ObjectInputStream獲取elementData。

Arrays.copyOf() 數組擴容

該方法在內部創建了一個新數組，底層實現是調用System.arraycopy()。

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
    T[] copy = ((Object)newType == (Object)Object[].class)
        ? (T[]) new Object[newLength]
        : (T[]) Array.newInstance(newType.getComponentType(), newLength);
    System.arraycopy(original, 0, copy, 0,
                     Math.min(original.length, newLength));
    return copy;
}

original - 要複製的數組

newLength - 要返回的副本的長度

newType - 要返回的副本的類型

System.arraycopy()

該方法是用了native關鍵字，調用的爲C++編寫的底層函數。

public static native void arraycopy(Object src,  int  srcPos,
                                    Object dest, int destPos,
                                    int length);

src - 源數組。

srcPos - 源數組中的起始位置。

dest - 目標數組。

destPos - 目標數據中的起始位置。

length - 要複製的數組元素的數量。

6，LinkedList源碼分析

看到網上都說LinkedList是一個環形鏈表結構，頭尾相連。但，當我開始看源碼的時候，發現並不是環形鏈表，是一個直線型鏈表結構，我一度以爲是我理解有誤。後來發現，JDK1.7之前的版本是環形鏈表，而到了JDK1.7以後進行了優化，變成了直線型鏈表結構。

集合基礎結構

1，在LinkedList中，內部類Node對象最爲重要，它組成了LinkedList集合的整個鏈表，分別指向上一個點、下一個結點，存儲着集合中的元素。

2，成員變量中，first表明是頭結點，last表明是尾結點。

public class LinkedList<E>
        extends AbstractSequentialList<E>
        implements List<E>, Deque<E>, Cloneable, java.io.Serializable {

    //LinkedList的元素個數：
    transient int size = 0;

    //LinkedList的頭結點：Node內部類
    transient java.util.LinkedList.Node<E> first;

    //LinkedList尾結點：Node內部類
    transient java.util.LinkedList.Node<E> last;

    //空實現：頭尾結點均爲null，鏈表不存在
    public LinkedList() {
    }

    //調用添加方法：
    public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c);
    }

    //節點的數據結構，包含前後節點的引用和當前節點
    private static class Node<E> {
        //結點元素：
        E item;
        //結點後指針
        java.util.LinkedList.Node<E> next;
        //結點前指針
        java.util.LinkedList.Node<E> prev;

        Node(java.util.LinkedList.Node<E> prev, E element, java.util.LinkedList.Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }
}

add() 添加

LinkedList的添加方法，主要分爲2種，一是直接添加一個元素，二是在指定角標下添加一個元素。

（1）add(E e)底層調用linkLast(E e)方法，就是在鏈表的最後面插入一個元素。

（2）add(int index, E element)，插入的角標如果==size，則插入到鏈表最後；否則，按照角標大小插入到對應位置。

//添加元素：添加到最後一個結點；
public boolean add(E e) {
    linkLast(e);
    return true;
}

//last節點插入新元素：
void linkLast(E e) {
    //將尾結點賦值個體L:
    final java.util.LinkedList.Node<E> l = last;
    //創建新的結點，將新節點的前指針指向l:
    final java.util.LinkedList.Node<E> newNode = new java.util.LinkedList.Node<>(l, e, null);
    //新節點置爲尾結點：
    last = newNode;
    //如果尾結點l爲null：則是空集合新插入
    if (l == null)
        //頭結點也置爲 新節點：
        first = newNode;
    else
        //l節點的後指針指向新節點：
        l.next = newNode;
    //長度+1
    size++;
    //操作數+1
    modCount++;
}

//向對應角標添加元素：
public void add(int index, E element) {
    //檢查傳入的角標 是否正確：
    checkPositionIndex(index);
    //如果插入角標==集合長度，則插入到集合的最後面：
    if (index == size)
        linkLast(element);
    else
        //插入到對應角標的位置：獲取此角標下的元素先
        linkBefore(element, node(index));
}
//在succ前插入 新元素e：
void linkBefore(E e, java.util.LinkedList.Node<E> succ) {
    //獲取被插入元素succ的前指針元素：
    final java.util.LinkedList.Node<E> pred = succ.prev;
    //創建新增元素節點，前指針 和 後指針分別指向對應元素：
    final java.util.LinkedList.Node<E> newNode = new java.util.LinkedList.Node<>(pred, e, succ);
    succ.prev = newNode;
    //succ的前指針元素可能爲null，爲null的話說明succ是頭結點，則把新建立的結點置爲頭結點：
    if (pred == null)
        first = newNode;
    else
        //succ前指針不爲null，則將前指針的結點的後指針指向新節點：
        pred.next = newNode;
    //長度+1
    size++;
    //操作數+1
    modCount++;
}

對於LinkedList集合增加元素來說，可以簡單的概括爲以下幾點：

1，將添加的元素轉換爲LinkedList的Node對象節點。

2，增加該Node節點的前後引用，即該Node節點的prev、next屬性，讓其分別指向哪一個節點）。

3，修改該Node節點的前後Node節點中pre/next屬性，使其指向該節點。

remove() 刪除元素

LinkedList的刪除也提供了2種形式，其一是通過角標刪除元素，其二就是通過對象刪除元素；不過，無論哪種刪除，最終調用的都是unlink來實現的。

//刪除對應角標的元素：
public E remove(int index) {
    checkElementIndex(index);
    //node()方法通過角標獲取對應的元素，在後面介紹
    return unlink(node(index));
}

//刪除LinkedList中的元素，可以刪除爲null的元素，逐個遍歷LinkedList的元素，重複元素只刪除第一個：
public boolean remove(Object o) {
    //如果刪除元素爲null：
    if (o == null) {
        for (java.util.LinkedList.Node<E> x = first; x != null; x = x.next) {
            if (x.item == null) {
                unlink(x);
                return true;
            }
        }
    } else {
        //如果刪除元素不爲null：
        for (java.util.LinkedList.Node<E> x = first; x != null; x = x.next) {
            if (o.equals(x.item)) {
                unlink(x);
                return true;
            }
        }
    }
    return false;
}

//移除LinkedList結點：remove()方法中調用
E unlink(java.util.LinkedList.Node<E> x) {
    //獲取被刪除結點的元素E：
    final E element = x.item;
    //獲取被刪除元素的後指針結點：
    final java.util.LinkedList.Node<E> next = x.next;
    //獲取被刪除元素的前指針結點：
    final java.util.LinkedList.Node<E> prev = x.prev;

    //被刪除結點的 前結點爲null的話：
    if (prev == null) {
        //將後指針指向的結點置爲頭結點
        first = next;
    } else {
        //前置結點的  尾結點指向被刪除的next結點；
        prev.next = next;
        //被刪除結點前指針置爲null:
        x.prev = null;
    }
    //對尾結點同樣處理：
    if (next == null) {
        last = prev;
    } else {
        next.prev = prev;
        x.next = null;
    }
    x.item = null;
    size--;
    modCount++;
    return element;
}

set() 修改元素

1，LinkedList的set(int index, E element)方法與add(int index,E element)的設計思路基本一致，都是創建新Node節點，插入到對應的角標下，修改前後節點的prev、next屬性。

2，其中，node(int index)方法至關重要，通過對應角標獲取到對應的集合元素。

3，可以看到，node（）中是根據角標的大小是選擇從前遍歷還是從後遍歷整個集合。也可以間接的說明，LinkedList在隨機獲取元素時性能很低，每次的獲取都得從頭或者從尾遍歷半個集合。

//設置對應角標的元素：
public E set(int index, E element) {
    checkElementIndex(index);
    //通過node()方法，獲取到對應角標的元素：
    java.util.LinkedList.Node<E> x = node(index);
    E oldVal = x.item;
    x.item = element;
    return oldVal;
}

//獲取對應角標所屬於的結點：
java.util.LinkedList.Node<E> node(int index) {
    //位運算：如果位置索引小於列表長度的一半，則從頭開始遍歷；否則，從後開始遍歷；
    if (index < (size >> 1)) {
        java.util.LinkedList.Node<E> x = first;
        //從頭結點開始遍歷：遍歷的長度就是index的長度，獲取對應的index的元素
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {
        //從集合尾結點遍歷：
        java.util.LinkedList.Node<E> x = last;
        //同樣道理：
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}

get() 獲取元素

get(int index)

在通過node(int index)獲取到對應節點後，返回節點中的item屬性，該屬性就是我們所保存的元素。

//獲取相應角標的元素：
public E get(int index) {
    //檢查角標是否正確：
    checkElementIndex(index);
    //獲取角標所屬結點的 元素值：
    return node(index).item;
}

迭代器

在LinkedList中，並沒有自己實現iterator()方法，而是使用其父類AbstractSequentialList的iterator()方法。

List<String> linkedList = new LinkedList<String>();
Iterator<String> iterator =  linkedList.iterator();

父類AbstractSequentialList中的 iterator():

public abstract class AbstractSequentialList<E> extends AbstractList<E> {
    public Iterator<E> iterator() {
        return listIterator();
    }
}

父類AbstractList中的 listIterator()：

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {            
    public ListIterator<E> listIterator() {
        return listIterator(0);
    }
}

LinkedList中的 listIterator()：

public ListIterator<E> listIterator(int index) {
    checkPositionIndex(index);
    return new ListItr(index);
}

private class ListItr implements ListIterator<E> {}

7，小結

本篇文章簡單介紹了Java中List集合，由於純手打，難免會有紕漏，如果發現錯誤的地方，請第一時間告訴我，這將是我進步的一個很重要的環節。