快捷導(dǎo)航

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

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

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

效率問(wèn)題：

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

同步性問(wèn)題：

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

普通替代方案：

使用迭代器刪除元素

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

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]
    }
}

臨時(shí)列表存儲(chǔ)刪除的元素

使用list.removeAll方法： 當(dāng)你在遍歷列表的同時(shí)刪除元素時(shí)，很容易觸發(fā) ConcurrentModificationException。使用臨時(shí)列表可以避免這個(gè)問(wèn)題，因?yàn)槟闶窃诒闅v結(jié)束后才進(jìn)行刪除操作。同時(shí)可以使代碼更加清晰易讀，你可以在一次遍歷中專注于識(shí)別要?jiǎng)h除的元素，并在另一次操作中執(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流進(jìn)行過(guò)濾

使用stream().filter方法過(guò)濾： Java 8 引入了 Stream API，可以使用filter方法來(lái)創(chuàng)建一個(gè)新的列表，只包含那些不需要?jiǎng)h除的元素。這種方式簡(jiǎn)潔且避免了并發(fā)修改的問(wèn)題，但是它會(huì)創(chuàng)建一個(gè)新列表，占用額外的內(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 開(kāi)始，List 接口提供了一個(gè) removeIf(Predicate<? super E> filter) 方法，允許你根據(jù)提供的謂詞刪除元素。這是一種簡(jiǎn)潔且高效的刪除方式。

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ā)安全方案：

避免遍歷和刪除同時(shí)進(jìn)行

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

import java.util.LinkedList;
import java.util.ListIterator;
?
public class ListDeletionListIterator {
?
    public static void main(String[] args) {
        // 創(chuàng)建一個(gè)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();
?
        // 移動(dòng)到第一個(gè)元素
        if (iterator.hasNext()) {
            iterator.next();  // 移動(dòng)到"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)來(lái)并行處理刪除操作。一種常見(jiàn)的做法是使用過(guò)濾（filtering）來(lái)生成一個(gè)新的列表，而不是直接修改原始列表。這種方法不會(huì)修改原始列表，而是返回一個(gè)新的不包含指定元素的列表。不過(guò)需要注意的是，并非所有情況并行處理都能帶來(lái)性能提升，它依賴于數(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)建一個(gè)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);
?
        // 使用并行流過(guò)濾出需要保留的元素
        List<String> filteredList = originalList.parallelStream()
                .filter(item -> !"Three".equals(item) && !"Four".equals(item))
                .collect(Collectors.toList());
?
        System.out.println("Filtered list: " + filteredList);
    }
}