List是Java集合框架中一個非常重要的接口，它代表了一個有序的集合，允許元素重復(fù)，并且可以按照插入的順序進(jìn)行訪問。

我們先來看看List在集合中的位置：

List是單列集合接口Collection下的一個分支，另兩個分支是Set和Queue，三者的區(qū)別：

• List集合中的元素是有序的、可重復(fù)的
• Set集合中的元素?zé)o需、不可重復(fù)
• Qeue集合中的元素遵循先進(jìn)先出的規(guī)則

一，List的繼承體系

List接口繼承自Collection接口，位于java.util包中。

List是有序集合的抽象表示，Java發(fā)展至今，List體系已經(jīng)非常龐雜。

從上圖看出，JDK中，直接或間接繼承List接口的有80個類。當(dāng)然，我們無需一一學(xué)習(xí)，通過三個常用的實(shí)現(xiàn)類的學(xué)習(xí)掌握原理即可：ArrayList、LinkedList和Vector。

• ArrayList：基于動態(tài)數(shù)組實(shí)現(xiàn)，提供了快速的隨機(jī)訪問。
• LinkedList：基于雙向鏈表實(shí)現(xiàn)，擅長插入和刪除操作，尤其是表頭和表尾的操作。
• Vector：早期版本的線程安全列表，與ArrayList相似，但現(xiàn)在多被ArrayList取代，因同步開銷較大。

二，List的常用操作及代碼示例

1，創(chuàng)建List實(shí)例

import java.util.*;
public class ListDemo {
    public static void main(String[] args) {
        List<String> arrayList = new ArrayList<>(); // 創(chuàng)建ArrayList實(shí)例
        List<String> linkedList = new LinkedList<>(); // 創(chuàng)建LinkedList實(shí)例
    }
}

2，增加元素

• add(E element)：在列表末尾添加元素。
• add(int index, E element)：在指定位置插入元素。

arrayList.add("Apple");
linkedList.add(0, "Banana"); // 在首位插入

3，訪問元素

• 通過索引訪問：get(int index)
• 遍歷：使用for-each循環(huán)或迭代器Iterator。

System.out.println(arrayList.get(0));
for (String fruit : arrayList) {
    System.out.println(fruit);
}

4，修改元素

• 使用set(int index, E element)方法替換指定位置的元素。

arrayList.set(0, "Orange");

5，刪除元素

• remove(int index)：根據(jù)索引刪除。
• remove(Object o)：根據(jù)元素刪除第一個匹配項(xiàng)。

arrayList.remove(0);
arrayList.remove("Orange");

6，判斷與查找

• contains(Object o)：判斷是否包含某元素。
• indexOf(Object o)：返回元素第一次出現(xiàn)的索引，未找到返回-1。
• lastIndexOf(Object o)：List集合中的元素可重復(fù)，返回元素最后一次出現(xiàn)的索引，未找到返回-1。

boolean hasApple = arrayList.contains("Apple");
int index = arrayList.indexOf("Apple");
int index = arrayList.lastIndexOf("Apple");

7，大小與清空

• size()：返回列表大小。
• clear()：清空列表。

int size = arrayList.size();
arrayList.clear();

8，List集合的遍歷

Java List 接口提供了多種方式來遍歷其中的元素，以下是三種常見的遍歷方式，每種方式都有相應(yīng)的代碼示例。

① 使用 for-each 循環(huán)

這是最簡潔也是最常用的遍歷方式，適用于Java 5及以后的版本。通過for-each循環(huán)，可以直接遍歷List中的每個元素，而無需手動管理索引。

代碼示例：

import java.util.ArrayList;
import java.util.List;
public class ListTraversal {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Cherry");
        // 使用for-each循環(huán)遍歷
        for (String fruit : fruits) {
            System.out.println(fruit);
        }
    }
}

并發(fā)修改異常ConcurrentModificationException

**注意，**使用for循環(huán)時，有可能會出現(xiàn)并發(fā)修改異常ConcurrentModificationException，如下面的例子，假設(shè)你有一個任務(wù)是遍歷一個List，檢查其中的元素，如果滿足某個條件，就從List中刪除該元素。

List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C", "D"));
for (String item : list) {
    if ("B".equals(item)) {
        list.remove(item); // 這里會拋出ConcurrentModificationException
    }
}

Java集合框架中的許多類，如ArrayList和LinkedList，為了檢測到并發(fā)修改，使用了所謂的“快速失敗”機(jī)制：

• ①當(dāng)?shù)鲃?chuàng)建之后，集合會維護(hù)一個名為modCount的字段來記錄集合的修改次數(shù)
• ②每當(dāng)集合通過迭代器之外的方式（如直接調(diào)用add或remove方法）發(fā)生修改時，modCount就會遞增
• ③迭代器在每次調(diào)用next或hasNext等方法時，都會檢查這個計(jì)數(shù)器是否發(fā)生變化，如果發(fā)現(xiàn)modCount不等于它內(nèi)部記錄的初始修改次數(shù)，就會拋出ConcurrentModificationException

據(jù)此分析，上面的代碼示例之所以會報錯，是因?yàn)椋?/p>

• ①使用for循環(huán)時會創(chuàng)建迭代器，迭代器會緩存當(dāng)前modCount的值
• ②在循環(huán)中使用了remove，modCount的值發(fā)生了變化
• ③下一循環(huán)時，迭代器會檢查緩存的modCount值與真實(shí)的modCount值是否一致，不一致就會拋出錯誤

并發(fā)修改異常的解決辦法

①使用迭代器的remove方法

正確的做法是在迭代過程中使用迭代器的remove方法來刪除元素，因?yàn)榈鞯?code>remove方法會在刪除元素后同時更新內(nèi)部的修改計(jì)數(shù)，以保持一致性。

Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String item = iterator.next();
    if ("B".equals(item)) {
        iterator.remove(); // 正確的刪除方式
    }
}

② 使用CopyOnWriteArrayList

對于多線程環(huán)境下的并發(fā)修改問題，可以考慮使用CopyOnWriteArrayList。這是一種線程安全的List實(shí)現(xiàn)，它通過在每次修改時創(chuàng)建集合的副本來避免并發(fā)修改異常，適合讀多寫少的場景。

List<String> list = new CopyOnWriteArrayList<>(Arrays.asList("A", "B", "C", "D"));
list.removeIf("B"::equals); // 線程安全的刪除操作

② 使用迭代器 Iterator

迭代器是一種更通用的遍歷集合的方法，適用于所有實(shí)現(xiàn)了Iterable接口的集合，包括List。通過調(diào)用List的iterator()方法獲取Iterator對象，然后使用hasNext()和next()方法進(jìn)行遍歷。

代碼示例：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ListTraversal {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Cherry");
        // 使用迭代器遍歷
        Iterator<String> iterator = fruits.iterator();
        while (iterator.hasNext()) {
            String fruit = iterator.next();
            System.out.println(fruit);
        }
    }
}

③ 使用Java 8的Stream API

從Java 8開始，可以使用Stream API來遍歷和處理集合中的元素，這種方式更加靈活，支持函數(shù)式編程風(fēng)格。

代碼示例：

import java.util.ArrayList;
import java.util.List;
public class ListTraversal {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Cherry");
        // 使用Stream API遍歷
        fruits.stream().forEach(System.out::println);
    }
}

④ 總結(jié)

• for-each循環(huán)：簡潔易讀，最適合日常使用。
• Iterator：提供了更多的控制權(quán)，比如在遍歷時移除元素，但在大多數(shù)情況下不如for-each方便。
• Stream API：功能強(qiáng)大，支持復(fù)雜的集合處理和并行處理，適合進(jìn)行復(fù)雜的聚合操作和過濾操作。

9，List集合的排序

在Java中，對List集合中的元素進(jìn)行排序可以通過多種方式實(shí)現(xiàn)，主要依賴于java.util.Collections類和List接口本身提供的排序方法。下面我將介紹幾種常見的排序方法，并提供相應(yīng)的代碼示例。

① 使用Collections.sort()方法

這是最直接的方式，適用于實(shí)現(xiàn)了Comparable接口的元素列表，進(jìn)行自然排序。

代碼示例（自然排序）：

import java.util.*;
class Person implements Comparable<Person> {
    String name;
    int age;
    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public int compareTo(Person other) {
        return Integer.compare(this.age, other.age); // 按年齡排序
    }
    @Override
    public String toString() {
        return name + " " + age;
    }
}
public class SortListExample {
    public static void main(String[] args) {
        List<Person> people = new ArrayList<>();
        people.add(new Person("Tom", 25));
        people.add(new Person("Jerry", 20));
        people.add(new Person("Bob", 30));
        Collections.sort(people);
        for (Person person : people) {
            System.out.println(person);
        }
    }
}

②使用Collections.sort()方法和自定義Comparator

如果列表中的元素沒有實(shí)現(xiàn)Comparable接口，或者你想根據(jù)不同的規(guī)則進(jìn)行排序，可以提供一個Comparator。

代碼示例（自定義比較器排序）：

import java.util.*;
public class SortListExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
        Collections.sort(names, new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return s2.compareTo(s1); // 倒序排序
            }
        });
        names.forEach(System.out::println); // 輸出：Charlie, Bob, Alice
    }
}

③使用List自帶的sort()方法

從Java 8開始，List接口直接提供了sort()方法，它同樣接受Comparator來控制排序邏輯。

代碼示例：

import java.util.*;
public class SortListExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9);
        numbers.sort(Integer::compareTo); // 自然排序
        System.out.println(numbers); // 輸出：[1, 1, 3, 4, 5, 9]
        numbers.sort(Collections.reverseOrder()); // 倒序排序
        System.out.println(numbers); // 輸出：[9, 5, 4, 3, 1, 1]
    }
}

④小結(jié)

• 使用Collections.sort()適用于不支持Lambda表達(dá)式的較早Java版本。
• 從Java 8開始，直接使用List的sort()方法配合Lambda表達(dá)式或方法引用來實(shí)現(xiàn)排序更為簡潔。
• 通過自定義Comparator，可以靈活地控制排序邏輯，適應(yīng)不同的排序需求。

三，不同List實(shí)現(xiàn)的底層原理及區(qū)別

ArrayList

• 底層原理：基于可變大小的數(shù)組實(shí)現(xiàn)，數(shù)組擴(kuò)容時會創(chuàng)建新數(shù)組并復(fù)制舊數(shù)據(jù)。
• 適用場景：當(dāng)需要頻繁查詢元素，且元素?cái)?shù)量變化不大時效率高。

LinkedList

• 底層原理：每個元素都是一個節(jié)點(diǎn)，包含前驅(qū)和后繼節(jié)點(diǎn)的引用，形成雙向鏈表。
• 適用場景：適合于頻繁的插入和刪除操作，尤其是在列表的開始或結(jié)尾。

Vector

• 底層原理：與ArrayList相似，但Vector是線程安全的，通過在關(guān)鍵方法上加鎖實(shí)現(xiàn)。
• 區(qū)別與注意事項(xiàng)：由于同步操作，Vector在多線程環(huán)境下更安全，但并發(fā)訪問時性能較低。現(xiàn)代開發(fā)中，推薦使用Collections.synchronizedList(List<T> list)或CopyOnWriteArrayList作為替代。

通過上述內(nèi)容，我們不僅了解了List接口的繼承體系、常用操作，還深入探討了ArrayList、LinkedList和Vector這三種常見實(shí)現(xiàn)的底層原理及其應(yīng)用場景。掌握這些知識，將有助于在實(shí)際開發(fā)中更加高效、靈活地使用List集合。

到此這篇關(guān)于Java集合中的List超詳細(xì)講解的文章就介紹到這了,更多相關(guān)java集合list內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論