快捷導(dǎo)航

Java從List中刪除元素的幾種方式小結(jié)

更新時間：2024年08月21日 08:58:30 作者：IT后浪1024

在Java中,List 接口提供了一個 remove(Object o) 方法來移除列表中與給定對象相等的第一個元素,然而,直接使用這個方法來刪除列表中的元素有時并不是最優(yōu)的選擇,主要原因包括效率和同步性問題,本文介紹了Java從List中刪除元素的幾種方式,需要的朋友可以參考下

效率問題：

線性搜索：remove(Object o) 方法需要遍歷列表直到找到與給定對象相等的第一個元素，這涉及到線性搜索，對于長度為 n 的列表，最壞情況下的時間復(fù)雜度為 O(n)。
移動元素：一旦找到目標元素，remove() 還需要將所有后續(xù)元素向前移動一位以填補空缺。這同樣需要 O(n) 的時間復(fù)雜度。因此，整個操作的時間復(fù)雜度為 O(n)。

同步性問題：

如果在迭代列表的同時使用 remove()，可能會導(dǎo)致迭代器失效或跳過元素，因為刪除操作改變了列表的大小，索引值對應(yīng)的數(shù)據(jù)也發(fā)生了變化。這可能導(dǎo)致未定義的行為或錯誤的結(jié)果。

普通替代方案：

使用迭代器刪除元素

使用迭代器的 remove() 方法：當遍歷列表并刪除元素時，建議使用迭代器的 remove() 方法。這種方法可以避免迭代器失效的問題，并且通常更安全

import java.util.Iterator;
import java.util.List;
import java.util.LinkedList;
?
public class ListDeletion {
    public static void main(String[] args) {
        List<String> list = new LinkedList<>();
        list.add("apple");
        list.add("banana");
        list.add("cherry");
?
        // 使用迭代器刪除元素
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String element = iterator.next();
            if ("banana".equals(element)) {
                iterator.remove();  // 安全地刪除元素
            }
        }
?
        System.out.println(list);  // 輸出: [apple, cherry]
    }
}

臨時列表存儲刪除的元素

使用list.removeAll方法： 當你在遍歷列表的同時刪除元素時，很容易觸發(fā) ConcurrentModificationException。使用臨時列表可以避免這個問題，因為你是在遍歷結(jié)束后才進行刪除操作。同時可以使代碼更加清晰易讀，你可以在一次遍歷中專注于識別要刪除的元素，并在另一次操作中執(zhí)行刪除操作。

import java.util.ArrayList;
import java.util.List;
?
public class ListDeletionTemporary {
?
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("apple");
        list.add("banana");
        list.add("cherry");
?
        List<String> itemsToRemove = new ArrayList<>();
        for (String item : list) {
            if ("banana".equals(item)) {
                itemsToRemove.add(item);
            }
        }
?
        list.removeAll(itemsToRemove);
        System.out.println(list);  // 輸出: [apple, cherry]
    }
}

使用Stream流進行過濾

使用stream().filter方法過濾： Java 8 引入了 Stream API，可以使用filter方法來創(chuàng)建一個新的列表，只包含那些不需要刪除的元素。這種方式簡潔且避免了并發(fā)修改的問題，但是它會創(chuàng)建一個新列表，占用額外的內(nèi)存。

public class ListDeletionStream {
?
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(Arrays.asList("apple", "banana", "cherry"));
?
        List<String> filteredList = list.stream()
                .filter(s -> !"banana".equals(s))
                .collect(Collectors.toList());
?
        System.out.println(filteredList);  // 輸出: [apple, cherry]
    }
}

使用List的removeIf方法

使用 removeIf(Predicate<? super E> filter) 方法：從 Java 8 開始，List 接口提供了一個 removeIf(Predicate<? super E> filter) 方法，允許你根據(jù)提供的謂詞刪除元素。這是一種簡潔且高效的刪除方式。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
?
public class ListDeletionRemoveIf {
?
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(Arrays.asList("apple", "banana", "cherry"));
        list.removeIf(s -> s.equals("banana")); // 刪除等于 "banana" 的所有元素
?
        System.out.println(list);
    }
}

并發(fā)安全方案：

避免遍歷和刪除同時進行

使用ListIterator可以避免并發(fā)修改異常，如果你想從List中刪除元素，并且希望在遍歷過程中能夠安全地移除元素而不引發(fā)ConcurrentModificationException異常，你應(yīng)該使用ListIterator。這是因為ListIterator提供了額外的方法來修改列表（如remove()），這些方法與迭代器的內(nèi)部狀態(tài)同步，可以避免并發(fā)修改的問題。

import java.util.LinkedList;
import java.util.ListIterator;
?
public class ListDeletionListIterator {
?
    public static void main(String[] args) {
        // 創(chuàng)建一個LinkedList并添加一些元素
        LinkedList<String> list = new LinkedList<>();
        list.add("One");
        list.add("Two");
        list.add("Three");
        list.add("Four");
        list.add("Five");
?
        System.out.println("Original list: " + list);
?
        // 獲取ListIterator
        ListIterator<String> iterator = list.listIterator();
?
        // 移動到第一個元素
        if (iterator.hasNext()) {
            iterator.next();  // 移動到"One"
        }
?
        // 刪除特定元素
        while (iterator.hasNext()) {
            String element = iterator.next();
            if ("Three".equals(element)) {  // 刪除"Three"
                iterator.remove();
            } else if ("Four".equals(element)) {  // 刪除"Four"
                iterator.remove();
            }
        }
?
        System.out.println("Modified list: " + list);
    }
}

利用多線程/并行處理

如果列表非常大，可以考慮使用并行流(parallel stream)來并行處理刪除操作。一種常見的做法是使用過濾（filtering）來生成一個新的列表，而不是直接修改原始列表。這種方法不會修改原始列表，而是返回一個新的不包含指定元素的列表。不過需要注意的是，并非所有情況并行處理都能帶來性能提升，它依賴于數(shù)據(jù)量和硬件配置。

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
?
public class ListDeletionParallelStream {
?
    public static void main(String[] args) {
        // 創(chuàng)建一個ArrayList并添加一些元素
        ArrayList<String> originalList = new ArrayList<>();
        originalList.add("One");
        originalList.add("Two");
        originalList.add("Three");
        originalList.add("Four");
        originalList.add("Five");
?
        System.out.println("Original list: " + originalList);
?
        // 使用并行流過濾出需要保留的元素
        List<String> filteredList = originalList.parallelStream()
                .filter(item -> !"Three".equals(item) && !"Four".equals(item))
                .collect(Collectors.toList());
?
        System.out.println("Filtered list: " + filteredList);
    }
}