Java-ArrayList集合的遍歷方式詳解
- 二、ArrayList概述
- 三、ArrayList的遍歷方式
- 1. 普通for循環遍歷
- 2. 增強for循環遍歷
- 3. 迭代器遍歷
- 4. ListIterator遍歷
- 5. Java 8 Stream API遍歷
- 四、性能對比與分析
- 性能測試結果分析
- 五、遍歷方式的選擇建議
- 六、常見遍歷陷阱與注意事項
- 1. 并發修改異常（ConcurrentModificationException）
- 2. 迭代器失效問題
- 3. 并行流的線程安全問題
- 總結
Java中ArrayList是常用的數據結構之一，它基于動態數組實現，允許我們存儲和操作對象集合。對ArrayList進行遍歷是日常開發中頻繁使用的操作，但遍歷方式多種多樣，不同場景下選擇合適的遍歷方式至關重要。本文我將詳細介紹ArrayList的各種遍歷方式、性能對比及適用場景，幫你在實際項目中做出最優選擇。
二、ArrayList概述
ArrayList是Java集合框架中List接口的一個實現類，位于java.util包下。它的底層是基于動態數組實現的，這意味著它可以根據元素的數量自動調整容量。與傳統數組相比，ArrayList的容量可以動態增長，提供了更靈活的元素存儲方式。
下面是一個簡單創建和使用ArrayList的示例：
import java.util.ArrayList;
import java.util.List;public class ArrayListDemo {public static void main(String[] args) {// 創建ArrayList實例List<String> list = new ArrayList<>();// 添加元素list.add("Java");list.add("Python");list.add("C++");// 訪問元素System.out.println("第一個元素：" + list.get(0));// 修改元素list.set(1, "JavaScript");// 刪除元素list.remove(2);// 打印ArrayListSystem.out.println("ArrayList內容：" + list);}
}
ArrayList的特點包括：
- 允許存儲null元素
- 元素有序且可重復
- 動態擴容，無需手動管理容量
- 支持隨機訪問，通過索引快速訪問元素
三、ArrayList的遍歷方式
1. 普通for循環遍歷
普通for循環是最基本的遍歷方式，通過控制索引來訪問ArrayList中的每個元素。
import java.util.ArrayList;
import java.util.List;public class ForLoopTraversal {public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("Apple");list.add("Banana");list.add("Cherry");// 普通for循環遍歷for (int i = 0; i < list.size(); i++) {System.out.println("元素" + i + "：" + list.get(i));}}
}
優點：
- 可以精確控制遍歷的起始和結束位置
- 支持雙向遍歷（修改索引的遞增方式）
- 可以在遍歷過程中修改元素（通過set方法）
缺點：
- 代碼相對繁瑣，需要手動管理索引
- 如果不注意索引范圍，容易出現IndexOutOfBoundsException異常
2. 增強for循環遍歷
增強for循環（也稱為foreach循環）是Java 5引入的語法糖，用于簡化集合和數組的遍歷。
import java.util.ArrayList;
import java.util.List;public class EnhancedForLoopTraversal {public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("Apple");list.add("Banana");list.add("Cherry");// 增強for循環遍歷for (String fruit : list) {System.out.println("水果：" + fruit);}}
}
優點：
- 代碼簡潔，減少了樣板代碼
- 提高了代碼的可讀性
- 避免了索引越界的風險
缺點：
- 無法獲取當前元素的索引（除非使用額外的計數器）
- 不支持在遍歷過程中修改集合結構（如添加、刪除元素）
- 只能單向遍歷
3. 迭代器遍歷
迭代器（Iterator）是Java集合框架提供的一種標準遍歷機制，所有實現了Collection接口的集合類都支持迭代器。
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;public class IteratorTraversal {public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("Apple");list.add("Banana");list.add("Cherry");// 獲取迭代器Iterator<String> iterator = list.iterator();// 使用迭代器遍歷while (iterator.hasNext()) {String fruit = iterator.next();System.out.println("水果：" + fruit);// 可以安全地刪除當前元素if ("Banana".equals(fruit)) {iterator.remove();}}System.out.println("刪除后的列表：" + list);}
}
優點：
- 提供了統一的遍歷接口，適用于所有實現了Collection接口的集合
- 支持在遍歷過程中安全地刪除元素（通過Iterator的remove方法）
缺點：
- 代碼相對冗長
- 只能單向遍歷
- 性能略低于普通for循環
4. ListIterator遍歷
ListIterator是Iterator的子接口，專門用于遍歷List集合，提供了比Iterator更豐富的功能。
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;public class ListIteratorTraversal {public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("Apple");list.add("Banana");list.add("Cherry");// 獲取ListIterator（從列表開頭開始）ListIterator<String> listIterator = list.listIterator();// 正向遍歷System.out.println("正向遍歷：");while (listIterator.hasNext()) {System.out.println("水果：" + listIterator.next());}// 反向遍歷（需要先將指針移到末尾）System.out.println("\n反向遍歷：");while (listIterator.hasPrevious()) {System.out.println("水果：" + listIterator.previous());}// 在遍歷過程中添加元素listIterator = list.listIterator();while (listIterator.hasNext()) {String fruit = listIterator.next();if ("Banana".equals(fruit)) {listIterator.add("Orange");}}System.out.println("\n添加后的列表：" + list);}
}
優點：
- 支持雙向遍歷（向前和向后）
- 支持在遍歷過程中添加、修改和刪除元素
- 可以獲取當前元素的索引位置
缺點：
- 只能用于List集合，通用性不如Iterator
- 代碼相對復雜，使用場景相對有限
5. Java 8 Stream API遍歷
Java 8引入的Stream API提供了一種函數式編程風格的集合處理方式，可以更簡潔地實現集合的遍歷和處理。
import java.util.ArrayList;
import java.util.List;public class StreamApiTraversal {public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("Apple");list.add("Banana");list.add("Cherry");// 使用Stream API的forEach方法遍歷System.out.println("使用Stream API遍歷：");list.stream().forEach(fruit -> {System.out.println("水果：" + fruit);});// 過濾并遍歷（只打印長度大于5的水果）System.out.println("\n過濾后的結果：");list.stream().filter(fruit -> fruit.length() > 5).forEach(fruit -> System.out.println("水果：" + fruit));// 并行流遍歷（適用于大數據量并行處理）System.out.println("\n使用并行流遍歷：");list.parallelStream().forEach(fruit -> {System.out.println("水果：" + fruit + "（線程：" + Thread.currentThread().getName() + "）");});}
}
優點：
- 代碼簡潔，支持鏈式操作
- 支持函數式編程風格，提高代碼可讀性
- 可以方便地進行過濾、映射、聚合等操作
- 并行流支持多線程并行處理，提高大數據量下的處理效率
缺點：
- 對于簡單的遍歷場景，可能顯得過于重量級
- 并行流在某些場景下可能引入線程安全問題和額外的開銷
- 調試相對困難
四、性能對比與分析
不同的遍歷方式在性能上可能存在差異，特別是在處理大量數據時。下面通過一個簡單的性能測試來比較各種遍歷方式的執行時間。
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;public class PerformanceComparison {public static void main(String[] args) {// 創建一個包含100萬個元素的ArrayListList<Integer> list = new ArrayList<>();for (int i = 0; i < 1000000; i++) {list.add(i);}// 測試普通for循環遍歷long startTime = System.currentTimeMillis();for (int i = 0; i < list.size(); i++) {list.get(i);}long endTime = System.currentTimeMillis();System.out.println("普通for循環遍歷耗時：" + (endTime - startTime) + "ms");// 測試增強for循環遍歷startTime = System.currentTimeMillis();for (Integer num : list) {// 空循環，僅測試遍歷時間}endTime = System.currentTimeMillis();System.out.println("增強for循環遍歷耗時：" + (endTime - startTime) + "ms");// 測試迭代器遍歷startTime = System.currentTimeMillis();Iterator<Integer> iterator = list.iterator();while (iterator.hasNext()) {iterator.next();}endTime = System.currentTimeMillis();System.out.println("迭代器遍歷耗時：" + (endTime - startTime) + "ms");// 測試ListIterator遍歷startTime = System.currentTimeMillis();ListIterator<Integer> listIterator = list.listIterator();while (listIterator.hasNext()) {listIterator.next();}endTime = System.currentTimeMillis();System.out.println("ListIterator遍歷耗時：" + (endTime - startTime) + "ms");// 測試Stream API遍歷startTime = System.currentTimeMillis();list.stream().forEach(num -> {// 空處理，僅測試遍歷時間});endTime = System.currentTimeMillis();System.out.println("Stream API遍歷耗時：" + (endTime - startTime) + "ms");// 測試并行流遍歷startTime = System.currentTimeMillis();list.parallelStream().forEach(num -> {// 空處理，僅測試遍歷時間});endTime = System.currentTimeMillis();System.out.println("并行流遍歷耗時：" + (endTime - startTime) + "ms");}
}
性能測試結果分析
在不同的測試環境下，各種遍歷方式的性能表現可能有所不同，但通常可以得出以下結論：
-
普通for循環在處理ArrayList時性能最優，因為它直接通過索引訪問元素，沒有額外的開銷。
-
增強for循環和迭代器遍歷的性能接近，它們在底層實現上是相似的。增強for循環實際上是迭代器的語法糖。
-
ListIterator遍歷的性能略低于普通迭代器，因為它提供了更多的功能。
-
Stream API遍歷的性能在處理小數據量時與增強for循環接近，但在大數據量下可能略慢。
-
并行流遍歷在多核處理器上處理大數據量時性能優勢明顯，但在小數據量或單核處理器上可能表現更差，因為并行流需要創建和管理線程池，帶來額外的開銷。
五、遍歷方式的選擇建議
根據不同的場景和需求，可以選擇合適的遍歷方式：
-
如果需要在遍歷過程中修改集合結構（添加、刪除元素），可以使用迭代器（Iterator或ListIterator）。特別是ListIterator支持在遍歷過程中添加、修改和刪除元素。
-
如果需要雙向遍歷，只能使用ListIterator。
-
如果代碼簡潔性是首要考慮，增強for循環是不錯的選擇。它適用于簡單的遍歷場景，不需要索引和修改集合結構的情況。
-
如果需要對元素進行復雜的處理或聚合操作，Stream API提供了更強大和靈活的功能。它支持過濾、映射、排序、聚合等操作，可以使代碼更加簡潔和可讀。
-
如果處理的數據量很大且在多核處理器上運行，可以考慮使用并行流提高性能。但要注意并行流可能引入的線程安全問題。
-
如果追求極致性能，特別是在處理大量數據時，普通for循環是最佳選擇。
六、常見遍歷陷阱與注意事項
1. 并發修改異常（ConcurrentModificationException）
在使用增強for循環或迭代器遍歷集合時，如果在遍歷過程中修改集合結構（添加、刪除元素），會拋出ConcurrentModificationException異常。
import java.util.ArrayList;
import java.util.List;public class ConcurrentModificationExample {public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("Apple");list.add("Banana");list.add("Cherry");// 錯誤示例：使用增強for循環刪除元素try {for (String fruit : list) {if ("Banana".equals(fruit)) {list.remove(fruit); // 會拋出ConcurrentModificationException}}} catch (Exception e) {e.printStackTrace();}// 正確示例：使用迭代器刪除元素list = new ArrayList<>();list.add("Apple");list.add("Banana");list.add("Cherry");java.util.Iterator<String> iterator = list.iterator();while (iterator.hasNext()) {String fruit = iterator.next();if ("Banana".equals(fruit)) {iterator.remove(); // 安全刪除元素}}System.out.println("刪除后的列表：" + list);}
}
2. 迭代器失效問題
在使用迭代器遍歷集合時，如果通過集合本身的方法（而不是迭代器的方法）修改集合結構，會導致迭代器失效。
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;public class IteratorInvalidationExample {public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("Apple");list.add("Banana");list.add("Cherry");Iterator<String> iterator = list.iterator();while (iterator.hasNext()) {String fruit = iterator.next();if ("Banana".equals(fruit)) {// 錯誤：使用集合的remove方法，而不是迭代器的remove方法list.remove(fruit); // 會導致迭代器失效}}}
}
3. 并行流的線程安全問題
在使用并行流處理集合時，如果操作共享資源，需要注意線程安全問題。
import java.util.ArrayList;
import java.util.List;public class ParallelStreamThreadSafety {public static void main(String[] args) {List<Integer> list = new ArrayList<>();for (int i = 0; i < 1000; i++) {list.add(i);}// 非線程安全的累加器int sum = 0;// 錯誤示例：并行流中修改非線程安全的共享變量list.parallelStream().forEach(num -> {sum += num; // 線程不安全的操作});System.out.println("錯誤的累加結果：" + sum); // 結果可能不正確// 正確示例：使用線程安全的累加器java.util.concurrent.atomic.AtomicInteger safeSum = new java.util.concurrent.atomic.AtomicInteger(0);list.parallelStream().forEach(num -> {safeSum.addAndGet(num); // 線程安全的操作});System.out.println("正確的累加結果：" + safeSum.get());}
}
總結
本文我詳細介紹了Java中ArrayList集合的多種遍歷方式：普通for循環、增強for循環、迭代器、ListIterator、Stream API和并行流。每種遍歷方式都有其特點和適用場景，應根據具體需求選擇合適的遍歷方式。
在實際開發中，除了考慮功能需求外，還應關注代碼的性能和可讀性。對于簡單的遍歷場景，建議優先使用增強for循環或Stream API；對于需要高性能的大數據量處理，普通for循環或并行流是更好的選擇；而在需要靈活控制遍歷過程的場景下，迭代器或ListIterator則更為合適。
若這篇內容幫到你，動動手指支持下！關注不迷路，干貨持續輸出！
ヾ(′? ˋ)ﾉヾ(′? ˋ)ﾉヾ(′? ˋ)ﾉヾ(′? ˋ)ﾉヾ(′? ˋ)ﾉ
