Java中集合遍歷的方法示例代碼展示

更新時間：2024年08月27日 11:24:11 作者：Bro_cat

在 Java 編程中,集合（Collection）是用于存儲和操作一組對象的重要工具,無論是數(shù)組、列表（List）、集合（Set）,還是映射（Map）,它們都提供了在不同場景下靈活使用的數(shù)據(jù)結(jié)構(gòu),這篇文章主要介紹了Java中集合遍歷的方法示例代碼展示,需要的朋友可以參考下

引言

在 Java 編程中，集合（Collection）是用于存儲和操作一組對象的重要工具。無論是數(shù)組、列表（List）、集合（Set），還是映射（Map），它們都提供了在不同場景下靈活使用的數(shù)據(jù)結(jié)構(gòu)。然而，僅僅將元素存儲在集合中是不夠的。為了實(shí)現(xiàn)對數(shù)據(jù)的有效操作和處理，我們需要遍歷這些集合，以便訪問、修改或計(jì)算其中的元素。

遍歷集合的方法有很多，每種方法都有其獨(dú)特的優(yōu)缺點(diǎn)和適用場景。了解并掌握這些遍歷方法，不僅可以幫助我們編寫更加高效和簡潔的代碼，還能在需要時充分利用 Java 提供的各種特性，如并行處理和函數(shù)式編程。下面，我們將探討幾種常見的遍歷集合的方法，并通過示例代碼展示它們的使用方式和特點(diǎn)。

使用迭代器和增強(qiáng)型for循環(huán)遍歷集合各有優(yōu)缺點(diǎn)，這兩種是常用的遍歷方法，下面是它們的對比：

迭代器（Iterator）

優(yōu)點(diǎn)：

靈活性：迭代器提供了更多的控制，可以在遍歷過程中刪除元素（使用iterator.remove()方法）。
統(tǒng)一接口：迭代器提供了一個統(tǒng)一的接口來遍歷各種集合類型（List、Set等）。

缺點(diǎn)：

代碼冗長：相比增強(qiáng)型for循環(huán)，使用迭代器需要更多的代碼。
可讀性：代碼可讀性稍差，因?yàn)樾枰@式地調(diào)用hasNext()和next()方法。

增強(qiáng)型for循環(huán)（for-each loop）

優(yōu)點(diǎn)：

簡潔性：代碼更簡潔，易于閱讀和編寫。
可讀性：代碼可讀性好，因?yàn)檎Z法更接近自然語言。

缺點(diǎn)：

功能限制：不能在遍歷過程中刪除元素（會拋出ConcurrentModificationException異常）。
適用性：只能用于遍歷，不能用于修改集合結(jié)構(gòu)（如刪除元素）。

示例對比

使用迭代器：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class IteratorExample {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(10);
        numbers.add(20);
        numbers.add(30);
        Iterator<Integer> iterator = numbers.iterator();
        int sum = 0;
        while (iterator.hasNext()) {
            int number = iterator.next();
            sum += number;
        }
        System.out.println("Sum: " + sum);
    }
}

使用增強(qiáng)型for循環(huán)：

import java.util.ArrayList;
import java.util.List;
public class ForEachExample {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(10);
        numbers.add(20);
        numbers.add(30);
        int sum = 0;
        for (int number : numbers) {
            sum += number;
        }
        System.out.println("Sum: " + sum);
    }
}

迭代器適用于需要更多控制和靈活性的場景，例如在遍歷過程中需要刪除元素。
增強(qiáng)型for循環(huán)適用于簡單的遍歷操作，代碼更簡潔，可讀性更好。

選擇哪種方式取決于具體的需求和代碼風(fēng)格。

迭代器的工作原理

迭代器（Iterator）在Java中是一個設(shè)計(jì)模式，用于遍歷集合對象的元素，而不需要暴露集合的內(nèi)部表示。迭代器的主要方法包括hasNext()、next()和remove()。

當(dāng)你創(chuàng)建一個迭代器時，它會指向集合的第一個元素之前的位置。每次調(diào)用next()方法時，迭代器會移動到下一個元素并返回該元素。當(dāng)?shù)鞯竭_(dá)集合的末尾時，hasNext()方法將返回false，表示沒有更多的元素可供遍歷。

為什么迭代器不能連續(xù)使用

迭代器不能連續(xù)使用通常是指在某些情況下，迭代器在遍歷過程中可能會失效。以下是一些可能導(dǎo)致迭代器失效的情況：

并發(fā)修改：如果在遍歷過程中，集合被其他線程修改（例如添加或刪除元素），迭代器可能會失效，并拋出ConcurrentModificationException異常。
集合結(jié)構(gòu)修改：即使在單線程環(huán)境中，如果在遍歷過程中直接修改集合的結(jié)構(gòu)（例如使用集合的remove()方法），迭代器也會失效。
迭代器生命周期：迭代器的生命周期通常與創(chuàng)建它的集合相關(guān)聯(lián)。一旦集合被修改，原有的迭代器可能會失效。

示例代碼

以下是一個可能導(dǎo)致迭代器失效的示例：

import java.util.*;
public class IteratorExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String element = iterator.next();
            if (element.equals("B")) {
                list.remove(element); // 這會導(dǎo)致ConcurrentModificationException
            }
        }
    }
}

在這個示例中，當(dāng)遍歷到元素"B"時，直接使用list.remove(element)修改了集合的結(jié)構(gòu)，導(dǎo)致迭代器失效并拋出ConcurrentModificationException異常。

正確的做法

如果需要在遍歷過程中刪除元素，應(yīng)該使用迭代器自身的remove()方法：

import java.util.*;
public class IteratorExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String element = iterator.next();
            if (element.equals("B")) {
                iterator.remove(); // 使用迭代器的remove方法
            }
        }
    }
}

在這個示例中，使用iterator.remove()方法可以安全地在遍歷過程中刪除元素，而不會導(dǎo)致迭代器失效。

總結(jié)

迭代器不能連續(xù)使用通常是因?yàn)樵诒闅v過程中集合被修改，導(dǎo)致迭代器失效。為了避免這種情況，應(yīng)該使用迭代器自身的remove()方法來修改集合，而不是直接使用集合的修改方法。

除了迭代器和增強(qiáng)型for循環(huán)，Java還提供了多種遍歷集合的方法。以下是一些常見的方法及其特點(diǎn)：

還有哪些遍歷方法

1. 傳統(tǒng)的for循環(huán)

特點(diǎn)：

索引訪問：可以通過索引訪問集合元素。
靈活性：可以在遍歷過程中修改集合（如刪除元素）。
適用性：適用于List等有序集合。

示例：

import java.util.ArrayList;
import java.util.List;
public class ForLoopExample {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(10);
        numbers.add(20);
        numbers.add(30);
        int sum = 0;
        for (int i = 0; i < numbers.size(); i++) {
            sum += numbers.get(i);
        }
        System.out.println("Sum: " + sum);
    }
}

2. Stream API（Java 8及以上）

特點(diǎn)：

簡潔性：代碼簡潔，易于閱讀。
功能強(qiáng)大：支持各種中間操作和終端操作（如過濾、映射、歸約等）。
并行處理：可以輕松實(shí)現(xiàn)并行處理。

示例：

import java.util.ArrayList;
import java.util.List;
public class StreamExample {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(10);
        numbers.add(20);
        numbers.add(30);
        int sum = numbers.stream()
                .mapToInt(Integer::intValue)
                .sum();
        System.out.println("Sum: " + sum);
    }
}

3. forEach方法（Java 8及以上）

特點(diǎn)：

簡潔性：代碼簡潔，易于閱讀。
函數(shù)式編程：可以使用lambda表達(dá)式。
適用性：適用于任何支持forEach方法的集合。

示例：

import java.util.ArrayList;
import java.util.List;
public class ForEachMethodExample {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(10);
        numbers.add(20);
        numbers.add(30);
        final int[] sum = {0};
        numbers.forEach(number -> sum[0] += number);
        System.out.println("Sum: " + sum[0]);
    }
}

4. 并行Stream（Java 8及以上）

特點(diǎn)：

并行處理：可以利用多核處理器并行處理集合。
簡潔性：代碼簡潔，易于閱讀。
適用性：適用于大數(shù)據(jù)集，可以提高處理速度。

示例：

import java.util.ArrayList;
import java.util.List;
public class ParallelStreamExample {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(10);
        numbers.add(20);
        numbers.add(30);
        int sum = numbers.parallelStream()
                .mapToInt(Integer::intValue)
                .sum();
        System.out.println("Sum: " + sum);
    }
}

5. 使用ListIterator（僅適用于List）

特點(diǎn)：

雙向遍歷：可以向前和向后遍歷List。
靈活性：可以在遍歷過程中修改集合（如添加或刪除元素）。
適用性：僅適用于List。

示例：

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class ListIteratorExample {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(10);
        numbers.add(20);
        numbers.add(30);
        int sum = 0;
        ListIterator<Integer> iterator = numbers.listIterator();
        while (iterator.hasNext()) {
            sum += iterator.next();
        }
        System.out.println("Sum: " + sum);
    }
}

6. 使用Spliterator（Java 8及以上）

特點(diǎn)：

并行處理：可以用于并行處理集合。
延遲遍歷：支持延遲遍歷，只在需要時處理元素。
適用性：適用于大數(shù)據(jù)集，可以提高處理速度。

示例：

import java.util.ArrayList;
import java.util.List;
import java.util.Spliterator;
public class SpliteratorExample {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(10);
        numbers.add(20);
        numbers.add(30);
        Spliterator<Integer> spliterator = numbers.spliterator();
        final int[] sum = {0};
        spliterator.forEachRemaining(number -> sum[0] += number);
        System.out.println("Sum: " + sum[0]);
    }
}