全文大約【5800】字，不說廢話，只講可以讓你學到技術、明白原理的純干貨!本文帶有豐富的案例及配圖視頻，讓你更好地理解和運用文中的技術概念，并可以給你帶來具有足夠啟迪的思考......

　　一. List集合簡介

　　1.概述

　　List本身是一個接口，該接口繼承自Collection接口，它有兩個常用的實現子類ArrayList和LinkedList。從功能特性上來看，List是有序、可重復的單列集合，集合中的每個元素都有對應的順序索引，我們可以通過該索引來訪問指定位置上的集合元素。默認情況下，List會按元素的添加順序給元素設置索引，第一個添加到List集合中的元素索引為0，第二個為1，后面依此類推。所以List的行為和數組幾乎完全相同，它們都是有序的存儲結構。另外List集合中允許有重復的元素，甚至可以有多個null值。

　　但是如果我們是使用數組來添加和刪除元素，就會非常的不方便。比如從一個已有的數組{'A', 'B', 'C', 'D', 'E'}中刪除索引為2的元素，這個“刪除”操作實際上是把'C'后面的元素依次往前挪一個位置;而“添加”操作實際上是把指定位置以后的元素依次向后挪一個位置，騰出位置給新加入的元素。針對這兩種操作，使用數組實現起來都會非常麻2. 類關系

　　我們來看看List接口的類關系，如下圖所示：煩。所以在實際應用中，我們增刪元素時，一般都是使用有序列表(如ArrayList)，而不是使用數組。

　　2.類關系

　　我們來看看List接口的類關系，如下圖所示：

　　從這個類關系中我們可以看到，List接口繼承了Collection接口，并且有ArrayList、LinkedList、Vector等子類，其中Vector現在已經不太常用了，所以我們重點掌握ArrayList和LinkedList就行。

　　3. 常用API方法

　　在List接口中定義了子類的一些通用方法，如下所示：

　　● boolean add(E e)：在集合末尾添加一個數據元素;

　　● boolean add(int index, E e)：在集合的指定索引出添加一個數據元素;

　　● E remove(int index)：刪除集合中指定索引的元素;

　　● boolean remove(Object e)：刪除集合中的某個元素;

　　● E get(int index)：獲取集合中指定索引出的元素;

　　● int size()：獲取集合的大小(包含元素的個數)。

　　以上這些方法，就是我們在開發時比較常用的幾個方法，大家需要記住哦。

　　4. List對象創建方式

　　List作為一個接口，我們通常不能直接new List來創建其對象，在Java中給我們提供了如下兩種創建List對象的方式：

　　● 通過多態方式創建：new List的某個子類，比如new ArrayList()等;

　　● 通過List.of()方法創建：of()方法可以根據給定的數據元素快速創建出List對象，但該方法不接受null值，如果傳入null會拋出NullPointerException異常。　　

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class Demo01 {
    public static void main(String[] args) {
        //創建List對象方式一：
        List<String> list1=new ArrayList<>();
        
        List<String> list2=new LinkedList<>();
        
        //創建List對象方式二：
        List<Integer> list3 = List.of(1,3,5,7,9);

        //該方式不能傳入null參數，否則會產生NullPointerException異常
        //List<Integer> list4 = List.of(1,3,5,7,9,null);
    }
}

　　5.List集合遍歷方式

　　很多時候，我們都會對集合進行遍歷操作，也就是要把集合中的每個元素挨個的取出來，以下是幾種常用的集合遍歷方式：

　　● 普通for循環配合get(索引值)方法進行遍歷：這種遍歷方式實現起來代碼較為復雜，且get(int)取值方法只對ArrayList比較高效，但對LinkedList效率較低，索引越大時訪問速度越慢。

　　● 增強for循環進行遍歷：我們也可以使用增強for循環進行遍歷，該方式比普通for循環實現起來更為簡潔。

　　● 使用Iterator迭代器進行集合遍歷：不同的List對象調用iterator()方法時，會返回不同實現的Iterator對象，該Iterator對象對集合總是具有最高的訪問效率。　　

import java.util.Iterator;
import java.util.List;

public class Demo02 {
    public static void main(String[] args) {
        //List遍歷方式一，普通for循環：
        List<String> list = List.of("java", "大數據", "壹小編");
        for(int i=0;i<list.size();i++) {
            System.out.println("遍歷方式一，值="+list.get(i));
        }
        
        //List遍歷方式二，迭代器：
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            //取出下一個值
            String value = it.next();
            System.out.println("遍歷方式二，值="+value);
        }

        //List遍歷方式三，增強for循環：內部會自動使用Iterator
        for(String item:list) {
            System.out.println("遍歷方式三，item="+item);
        }
    }
}

　　上面提到的Iterator對象，有兩個常用方法，如下所示：

　　● boolean hasNext()：該方法用于判斷集合中是否還有下一個元素;

　　● E next()：該方法用于返回集合的下一個元素。

　　雖然使用Iterator遍歷List集合的代碼，看起來比使用索引較復雜，但Iterator遍歷List集合的效率卻是最高效的方式。

　　另外只要是實現了Iterable接口的集合類，我們都可以直接使用for each增強循環來遍歷。在增強for循環中，Java編譯器會自動把for each循環變成基于Iterator方式的遍歷方式。

　　6. List與數組的轉換方式

　　其實List與Array數組在很多地方都是比較相似的，比如都可以根據索引對數據元素進行遍歷取值等操作。因為存在著這種相似之處，所以在List和數組之間是可以互相轉換的，即List集合可以轉成數組，數組也可以轉成List集合。

　　6.1 List轉數組

　　一般情況下，List轉數組有如下幾種方式：

　　● toArray()方法：該方法會返回一個Object[]數組，但該方法會丟失類型信息，在實際開發時較少使用;

　　● toArray(T[])方法：傳入一個與集合的數據元素類型相同的Array，List會自動把元素復制到傳入的Array中;

　　● T[] toArray(IntFunction generator)方法：函數式寫法，這是Java中的新特性，后面小編會單獨講解。　

import java.util.List;

public class Demo03 {
    public static void main(String[] args) {
        List<String> list = List.of("java", "大數據", "壹小編");
        
        // List轉數組方式一：返回一個Object[]數組
        Object[] array = list.toArray();
        for (Object val : array) {
            System.out.println("方式一，value="+val);
        }
        
        // List轉數組方式二，給toArray(T[])傳入與數組元素類型相同的Array，如果數組類型與集合數據元素類型不匹配則會產生如下異常：
        // java.lang.ArrayStoreException: arraycopy: element type mismatch: 
        //can not cast one of the elements of java.lang.Object[] to the type of the destination array, java.lang.Integer
        String[] array2 = list.toArray(new String[list.size()]);
        for (String val : array2) {
            System.out.println("方式二，value="+val);
        }
        
        // List轉數組方式三：返回一個String[]數組
        String[] array3 = list.toArray(String[]::new);
        for (String val : array3) {
            System.out.println("方式二，value="+val);
        }
    }
}

　　在本案例中，第一種實現方式是調用toArray()方法直接返回一個Object[]數組，但這種方法會丟失類型信息，所以開發是很少使用。

　　第二種方式要給toArray(T[])方法傳入一個與集合數據元素類型相同的Array，List內部會自動把元素復制到傳入的Array數組中。如果Array類型與集合的數據元素類型不匹配，就會產生”java.lang.ArrayStoreException: arraycopy: element type mismatch: can not cast one of the elements of java.lang.Object[] to the type of the destination array......“異常。

　　第三種方式是通過List接口定義的T[] toArray(IntFunction generator)方法，這是一種函數式寫法，小編以后再單獨給大家講解。

　　6.2 數組轉List

　　反過來，數組也可以轉為List集合，一般的方式如下：

　　● List.of(T...)方法：該方法會返回一個只讀的List集合，如果我們對只讀List調用add()、remove()方法會拋出UnsupportedOperationException異常。其中的T是泛型參數，代表要轉成List集合的數組;

　　● Arrays.asList(T...)方法：該方法也會返回一個List集合，但它返回的List不一定就是ArrayList或者LinkedList，因為List只是一個接口。　

import java.util.Arrays;
import java.util.List;

public class Demo04 {
    public static void main(String[] args) {
        // 數組轉List的方式一：List.of()返回一個只讀的集合，不能進行add/remove等修改操作。
        List<Integer> values = List.of(1,8,222,10,5);
        for (Integer val : values) {
            System.out.println("方式一，value="+val);
            
            //該集合是一種只讀的集合，不能在遍歷時進行增刪改等更新操作，只能進行讀取操作，
            //否則會產生java.lang.UnsupportedOperationException異常
            //values.remove(0);
        }
        
        // 數組轉List的方式二：Arrays.asList()返回一個只讀的集合，不能進行add/remove等修改操作。
        List<String> items = Arrays.asList("java","壹小編","元宇宙");
        for (String item : items) {
            System.out.println("方式二，value="+item);
            
            //不可以進行增刪改操作
            //items.add("sss");
            //items.remove(0);
        }
    }
}

　　在本案例中，無論我們是通過List.of()方法，還是通過Arrays.asList()方法，都只會返回一個只讀的集合。這種集合在遍歷時不能進行增刪改等更新操作，只能進行讀取操作，否則會產生java.lang.UnsupportedOperationException異常。

　　二. ArrayList集合

　　1.簡介

　　ArrayList是一個數組隊列，位于java.util包中，它繼承自AbstractList，并實現了List接口。其底層是一個可以動態修改的數組，該數組與普通數組的區別，在于它沒有固定的大小限制，我們可以對其動態地進行元素的添加或刪除。

　　存儲在集合內的數據被稱為”元素“，我們可以利用索引來訪問集合中的每個元素。為了方便我們操作這些元素，ArrayList給我們提供了相關的添加、刪除、修改、遍歷等功能。

　　因為ArrayList的底層是一個動態數組，所以該集合適合對元素進行快速的隨機訪問(遍歷查詢)，另外尾部成員的增加和刪除操作速度也較快，但是其他位置上元素的插入與刪除速度相對較慢。基于這種特性，所以ArrayList具有查詢快，增刪慢的特點。

　　2.常用方法

　　ArrayList給我們提供了如下這些方法，我們可以先來了解一下：

　　接下來小編就挑選幾個常用的方法，通過幾個案例來給大家講解一下ArrayList的用法。

　　3.添加元素

　　ArrayList給我們提供了多個與添加相關的方法，比如add()和addAll()方法，可以將元素添加到集合中。另外如果我們要計算ArrayList中元素的數量，可以使用size()方法。　

import java.util.ArrayList;

public class Demo05 {
    public static void main(String[] args) {
        //創建ArrayList集合，<String>中的是泛型，后面我們會專門講解泛型
        ArrayList<String> names = new ArrayList<String>();
        //一個一個地添加元素
        names.add("java");
        names.add("數學");
        
        //遍歷集合
        for (String name : names) {
            System.out.println("name="+name+",size="+names.size());
        }
        
        ArrayList<String> names2 = new ArrayList<String>();
        names2.add();
        //在A集合中追加B集合
        names2.addAll(names);
        
        //遍歷集合
        for (String name : names2) {
            System.out.println("name="+name);
        }
    }
}

　　在上面的代碼中，這部分是泛型，小編會在后面給大家專門講解，敬請期待哦。

　　4. 遍歷元素

　　我們對ArrayList中元素進行遍歷的方式，其實與List的遍歷是一樣的，我們可以使用普通for循環、增強for循環、Iterator迭代器等方式對集合進行遍歷，這里我們就不再單獨展示其用法了。

　　5. 修改元素

　　我們使用add()方法將元素添加到集合中之后，如果想對集合中的元素進行修改，可以使用set()方法。　

import java.util.ArrayList;

public class Demo06 {
    public static void main(String[] args) {
        //創建ArrayList集合，<String>中的是泛型，后面我們會專門講解泛型
        ArrayList<String> names = new ArrayList<String>();
        //一個一個地添加元素
        names.add("java");
        names.add("數學");
        
        //修改集合中的元素：第一個參數是集合中的索引，第二個是要修改的值
        names.set(1, "Android"); 
        names.set(2, "iOS"); 
        
        //遍歷集合
        for (String name : names) {
            System.out.println("name="+name);
        }
    }
}

　　6.刪除元素

　　如果我們要刪除ArrayList中的元素，可以使用remove()、removeAll()等方法。　

import java.util.ArrayList;

public class Demo07 {
    public static void main(String[] args) {
        //創建ArrayList集合，<String>中的是泛型，后面我們會專門講解泛型
        ArrayList<String> names = new ArrayList<String>();
        //一個一個地添加元素
        names.add("java");
        names.add("數學");
        
        //刪除集合中指定位置上的某個元素
        names.remove(0);
        //刪除集合中的某個指定元素
        names.remove("java");
        
        //遍歷集合
        for (String name : names) {
            System.out.println("name="+name);
        }
        
        ArrayList<String> names2 = new ArrayList<String>();
        names2.add("語文");
        names2.add("英語");
        names2.add("數學");
        //刪除本集合中的另一個集合
        names2.removeAll(names);
        //遍歷集合
        for (String name : names2) {
            System.out.println("name2="+name);
        }
    }
}

　　7.集合排序

　　我們可以使用Collections.sort()方法對集合進行升序排列。　

import java.util.ArrayList;
import java.util.Collections;

public class Demo08 {

    public static void main(String[] args) {
        //創建ArrayList集合
        ArrayList<Integer> nums = new ArrayList<>();
        //一個一個地添加元素
        nums.add(100);
        nums.add(85);
        nums.add(120);
        nums.add(55);
        
        //對集合進行排序,默認是升序排列
        Collections.sort(nums);  
        
        //遍歷集合
        for (Integer num : nums) {
            System.out.println("num="+num);
        }
    }
}

　　三. LinkedList集合

　　1.簡介

　　LinkedList采用鏈表結構來保存數據，所以是一種鏈表集合，類似于ArrayList，也是List的一個子類，位于java.util包中。它的底層是基于線性鏈表這種常見的數據結構，但并沒有按線性的順序存儲數據，而是在每個節點中都存儲了下一個節點的地址。

　　LinkedList的優點是便于向集合中插入或刪除元素，尤其是需要頻繁地向集合中插入和刪除元素時，使用LinkedList類比ArrayList的效率更高。但LinkedList隨機訪問元素的速度則相對較慢，即檢索集合中特定索引位置上的元素速度較慢。

　　2. LinkedList類關系

　　LinkedList直接繼承自AbstractSequentialList，并實現了List、Deque、Cloneable、Serializable等多個接口。通過實現List接口，具備了列表操作的能力;通過實現Cloneable接口，具備了克隆的能力;通過實現Queue和Deque接口，可以作為隊列使用;通過實現Serializable接口，可以具備序列化能力。LinkedList類結構關系如下圖所示：

　　3. LinkedList與ArrayList對比

　　與ArrayList相比，LinkedList進行添加和刪除的操作效率更高，但查找和修改的操作效率較低。基于這種特性，我們可以在以下情況中使用ArrayList:

　　● 需要經常訪問獲取列表中的某個元素;

　　● 只需要在列表的末尾進行添加和刪除某個元素。

　　當遇到如下情況時，可以考慮使用LinkedList:

　　● 需要經常通過循環迭代來訪問列表中的某些元素;

　　● 需要經常在列表的開頭、中間、末尾等位置進行元素的添加和刪除操作。

　　4. 常用方法

　　LinkedList中的很多方法其實都來自于List接口，所以它的很多方法與ArrayList是一樣的。但由于其自身特點，也具有一些特有的常用方法，這里小編只列出LinkedList特有的常用方法，如下表所示：

　　對這些方法進行基本的了解之后，接下來我們選擇幾個核心方法來來看看具體該怎么使用。

　　5. 添加/刪除元素

　　我們可以通過addFirst()和addLast()方法，分別在鏈表的開頭和結尾添加一個元素。當我們要頻繁地在一個列表的開頭和結尾進行元素添加、刪除時，使用LinkedList要比ArrayList的效率更高。　

import java.util.LinkedList;

public class Demo09 {

    public static void main(String[] args) {
        // 創建LinkedList集合
        LinkedList<String> names = new LinkedList<String>();
        // 一個一個地添加元素
        names.add("java");
        names.add("數學");

        //在鏈表的開頭添加元素
        names.addFirst("");
        
        //在鏈表的結尾添加元素
        names.addLast("歷史");

        // 遍歷集合
        for (String name : names) {
            System.out.println("name=" + name);
        }

        //移除鏈表開頭的元素
        names.removeFirst();
        //移除鏈表結尾的元素
        names.removeLast();
    }
}

　　6.迭代獲取元素

　　我們可以通過getFirst()、getLast()等方法獲取到集合中的第一個、最后一個元素。　

import java.util.LinkedList;

public class Demo10 {
    public static void main(String[] args) {
        // 創建LinkedList集合
        LinkedList<String> names = new LinkedList<String>();
        // 一個一個地添加元素
        names.add("java");
        names.add("數學");

        System.out.println("first=" + names.getFirst());
        System.out.println("last=" + names.getLast());

        // 迭代遍歷集合
        for (String name : names) {
            System.out.println("name=" + name);
        }
    }
}

　　四. 結語

　　至此，小編就把List集合給大家講解完畢了，最后我們再來看看本文的重點吧：

　　● List是按索引順序訪問的、長度可變的有序列表;

　　● 一般開發時，ArrayList比LinkedList的使用更頻繁;

　　● List和Array可以相互轉換;

　　● 集合遍歷時有多種方式，增強for循環和Iterator迭代器的效率更高;

　　● ArrayList與LinkedList都是List接口的實現類，都實現了List中所有未實現的方法，但實現的方式有所不同;

　　● ArrayList底層的數據結構基于動態數組，訪問元素速度快于LinkedList，在快速訪問數據時ArrayList的執行效率比較高;

　　● LinkedList底層的數據結構基于鏈表，占用的內存空間較大，但批量插入或刪除數據時快于ArrayList。當頻繁向集合中插入和刪除元素時，使用LinkedList比ArrayList的效率更高。