2. 程式人生 > 實用技巧 >正向遍歷和反向遍歷

正向遍歷和反向遍歷

阿新 • • 發佈：2020-11-14

前言

之前搜尋面試題的時候，出現了一個題：一個ArrayList在迴圈過程中刪除，會不會出問題，為什麼？心裡想的答案是肯定會有問題但是又不知道是為什麼，在搜尋到答案後，發現裡面其實並不簡單，所以專門寫篇文章研究一下。

for迴圈正向刪除

先看示例，再解析原因：

  1. public static void main(String[] args){
  2. List<String> list = new ArrayList<String>();
  4. list.add("111");
  5. list.add("222");
  6. list.add("222");
  7. list.add("333");
  8. list.add("444");
  9. list.add("333");
  10. //for迴圈正向迴圈刪除
  11. for (int i = 0;i < list.size();i++){
  12. if (list.get(i).equals("222")){
  13. list.remove(i);
  14. }
  15. }
  16. System.out.println(Arrays.toString(list.toArray()));
  17. }

執行後，輸出結果：

[111, 222, 333, 444, 333]

發現，相鄰的字串“222”沒有刪除，這是為什麼呢？畫圖解釋：

解釋：刪除元素“222”，當迴圈到下標為1的元素的的時候，發現此位置上的元素是“222”，此處元素應該刪除，根據上圖中的元素移動可知，在刪除元素後面的所有元素都要向前移動一個位置，那麼移動之後，原來下標為2的元素“222”，此時下標為1，這是在i = 1,時的迴圈操作，在下一次的迴圈中，i = 2，此時就遺漏了第二個元素“222”。

那麼再做下一個測試，刪除元素“333”，結果將如何？

  1. public static void main(String[] args){
  2. List<String> list = new ArrayList<String>();
  4. list.add("111");
  5. list.add("222");
  6. list.add("222");
  7. list.add("333");
  8. list.add("444");
  9. list.add("333");
  10. //for迴圈正向迴圈刪除
  11. for (int i = 0;i < list.size();i++){
  12. if (list.get(i).equals("333")){
  13. list.remove(i);
  14. }
  15. }
  16. System.out.println(Arrays.toString(list.toArray()));
  17. }

執行結果：

[111, 222, 222, 444]

發現，沒有問題。原理在上一個測試已經說了，就不再贅述。

總結：for迴圈正向刪除，會遺漏連續重複的元素。

for迴圈反向刪除

  1. public static void main(String[] args){
  2. List<String> list = new ArrayList<String>();
  4. list.add("111");
  5. list.add("222");
  6. list.add("222");
  7. list.add("333");
  8. list.add("444");
  9. list.add("333");
  10. //for迴圈反向迴圈刪除
  11. for (int i = list.size() - 1;i >= 0;i--){
  12. if (list.get(i).equals("222")){
  13. list.remove(i);
  14. }
  15. }
  16. System.out.println(Arrays.toString(list.toArray()));
  17. }

執行結果：

[111, 333, 444, 333]

發現，沒有問題。還是畫圖解釋：

反向刪除的時候，迴圈遍歷完了的元素下標才有可能移動（已經遍歷的元素，下標變化了也沒有影響），所以沒有遍歷的下標不會移動，自反向刪除會遍歷到所有的元素，正向會跳過一些元素。

總結：反向遍歷刪除，沒有問題（單執行緒）。

反向遍歷刪除（多執行緒）

  1. public static void main(String[] args) {
  2. ArrayList<String> list = new ArrayList<String>();
  3. list.add("111");
  4. list.add("222");
  5. list.add("222");
  6. list.add("333");
  7. list.add("444");
  8. list.add("333");
  10. Thread thread1 = new Thread() {
  11. @Override
  12. public void run() {
  13. remove(list,"111");
  14. try {
  15. Thread.sleep(1000);
  16. } catch (InterruptedException e) {
  17. e.printStackTrace();
  18. }
  19. }
  20. };
  21. Thread thread2 = new Thread() {
  22. @Override
  23. public void run() {
  24. remove(list, "222");
  25. try {
  26. Thread.sleep(1000);
  27. } catch (InterruptedException e) {
  28. e.printStackTrace();
  29. }
  30. }
  31. };
  32. Thread thread3 = new Thread() {
  33. @Override
  34. public void run() {
  35. remove(list, "333");
  36. try {
  37. Thread.sleep(1000);
  38. } catch (InterruptedException e) {
  39. e.printStackTrace();
  40. }
  41. }
  42. };
  43. // 使各個執行緒處於就緒狀態
  44. thread1.start();
  45. thread2.start();
  46. thread3.start();
  47. // 等待前面幾個執行緒完成
  48. try {
  49. thread1.join();
  50. thread2.join();
  51. } catch (InterruptedException e) {
  52. e.printStackTrace();
  53. }
  55. System.out.println(Arrays.toString(list.toArray()));
  56. }
  58. public static void remove(ArrayList<String> list, String elem) {
  59. // 普通for迴圈倒序刪除，刪除過程中元素向左移動，不影響連續刪除
  60. for (int i = list.size() - 1; i >= 0; i--) {
  61. if (list.get(i).equals(elem)) {
  62. list.remove(list.get(i));
  63. }
  64. }
  65. }

執行結果：

[444]

總結：多執行緒反向遍歷刪除，沒有問題。

Iterator迴圈刪除

  1. public static void main(String[] args){
  2. List<String> list = new ArrayList<String>();
  4. list.add("111");
  5. list.add("222");
  6. list.add("222");
  7. list.add("333");
  8. list.add("444");
  9. list.add("333");
  10. //foreach迴圈刪除
  11. Iterator iterator = list.iterator();
  12. while (iterator.hasNext()){
  13. if (iterator.next().equals("222")){
  14. list.remove(iterator.next());
  15. }
  16. }
  17. System.out.println(Arrays.toString(list.toArray()));
  18. }

執行結果：

  1. Exception in thread "main" java.util.ConcurrentModificationException
  2. at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
  3. at java.util.ArrayList$Itr.next(ArrayList.java:859)
  4. at joe.effective.Test.main(Test.java:20)

這個問題就要藉助原始碼來分析了（JDK1.8）：

  1. public E remove(int index) {
  2. rangeCheck(index);
  4. modCount++;
  5. E oldValue = elementData(index);
  7. int numMoved = size - index - 1;
  8. if (numMoved > 0)
  9. System.arraycopy(elementData, index+1, elementData, index,
  10. numMoved);
  11. elementData[--size] = null; // clear to let GC do its work
  13. return oldValue;
  14. }
  16. public boolean remove(Object o) {
  17. if (o == null) {
  18. for (int index = 0; index < size; index++)
  19. if (elementData[index] == null) {
  20. fastRemove(index);
  21. return true;
  22. }
  23. } else {
  24. for (int index = 0; index < size; index++)
  25. if (o.equals(elementData[index])) {
  26. fastRemove(index);
  27. return true;
  28. }
  29. }
  30. return false;
  31. }
  33. private void fastRemove(int index) {
  34. modCount++;
  35. int numMoved = size - index - 1;
  36. if (numMoved > 0)
  37. System.arraycopy(elementData, index+1, elementData, index,
  38. numMoved);
  39. elementData[--size] = null; // clear to let GC do its work
  40. }

可以看出，ArrayList的remove方法，一種是根據下標刪除，一種是根據元素刪除。

發現即使看了remove方法的原始碼也不能找到報錯的原因，由於我們使用了Iterator迭代器，那麼再看看迭代器的原始碼，果不其然，就發現了問題所在：

  1. private class Itr implements Iterator<E>
  2. private class ListItr extends Itr implements ListIterator<E>
  1. public void remove() {
  2. if (lastRet < 0)
  3. throw new IllegalStateException();
  4. checkForComodification(); // 檢查修改次數
  6. try {
  7. ArrayList.this.remove(lastRet);
  8. cursor = lastRet;
  9. lastRet = -1;
  10. expectedModCount = modCount;
  11. } catch (IndexOutOfBoundsException ex) {
  12. throw new ConcurrentModificationException();
  13. }
  14. }
  15. final void checkForComodification() {
  16. if (modCount != expectedModCount)
  17. throw new ConcurrentModificationException();
  18. }

Itr和ListItr是ArrayList的兩個私有內部類，Itr實現了Iterator介面，ListItr繼承了Itr類和實現了ListIterator介面。Itr類中也有一個remove方法，迭代器實際呼叫的也正是這個remove方法，上述原始碼也就是這個方法的原始碼。

由原始碼的第二段程式碼可以看出，這個remove方法中呼叫了ArrayList中的remove方法，在這個方法中我們注意到了expectedModCount變數和modCount變數，modCount在前面的程式碼中也見到了，它記錄了ArrayList修改的次數，而前面的變數expectedModCount，這個變數的初值和modCount是相等的；同時在ArrayList.this.remove(lastRet)；程式碼面前，呼叫了檢查次數的方法checkForComodification()，這個方法做的事情很簡單，就是如果expectedModCount和modCount不相等，那麼就丟擲異常ConcurrentModificationException。

我們在用Iterator迴圈刪除的時候，呼叫的是ArrayList裡面的remove方法，刪除元素後modCount會增加，expectedModCount則不變，這樣就造成了expectedModCount ！= modCount，那麼就丟擲異常了。

再用Iterator中的remove方法來測試：

  1. public static void main(String[] args){
  2. List<String> list = new ArrayList<String>();
  4. list.add("111");
  5. list.add("222");
  6. list.add("222");
  7. list.add("333");
  8. list.add("444");
  9. list.add("333");
  11. Iterator iterator = list.iterator();
  12. while (iterator.hasNext()){
  13. if (iterator.next().equals("222")){
  14. iterator.remove();
  15. }
  16. }
  17. System.out.println(Arrays.toString(list.toArray()));
  18. } 
執行結果[111, 333, 444, 333]

發現，刪除成功且沒有報錯。

什麼原因呢？我們呼叫的了Iterator中的迭代器刪除元素，在這個方法中有：expectedModCount = modCount這樣一句程式碼，所以當我們每刪除一次元素，就同步一次，所以呼叫checkForComodification()時，就不會報錯。如果換到多執行緒中，這個方法不能保證兩個變數修改的一致性，結果具有不確定性，所以不推薦這種方法。

總結：Iterator呼叫ArrayList的刪除方法報錯，Iterator呼叫迭代器自己的刪除方法，單執行緒不會報錯，多執行緒會報錯。

forEach迴圈刪除

  1. public static void main(String[] args){
  2. List<String> list = new ArrayList<String>();
  4. list.add("111");
  5. list.add("222");
  6. list.add("222");
  7. list.add("333");
  8. list.add("444");
  9. list.add("333");
  10. //foreach迴圈刪除
  11. for (String str : list){
  12. if (str.equals("222")){
  13. list.remove(str);
  14. }
  15. }
  17. System.out.println(Arrays.toString(list.toArray()));
  18. }
  1. 執行結果
  2. Exception in thread "main" java.util.ConcurrentModificationException
  1. at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
  2. at java.util.ArrayList$Itr.next(ArrayList.java:859)
  3. at joe.effective.Test.main(Test.java:20)

報錯。

foreach原理是因為這些集合類都實現了Iterable介面，該介面中定義了Iterator迭代器的產生方法，並且foreach就是通過Iterable介面在序列中進行移動。也就是說：在編譯的時候編譯器會自動將對for這個關鍵字的使用轉化為對目標的迭代器的使用

明白了原理就跟上述的Iterator刪除呼叫ArrayList中remove一樣了。

總結：forEach迴圈刪除報錯。

相關推薦

正向遍歷和反向遍歷

前言 之前搜尋面試題的時候，出現了一個題：一個ArrayList在迴圈過程中刪除，會不會出問題，為什麼？心裡想的答案是肯定會有問題但是又不知道是為什麼，在搜尋到答案後，發現裡面其實並不簡單，所以專門寫篇文章研究

關於圖片載入後遍歷 和 ajax遍歷

需求： 根據圖片的豎圖、橫圖（比較長寬），用不同的樣式。橫圖：width：100%； 豎圖：height： 100%。需要相容ie8

內的 物件 獲取 鍵值對_陣列遍歷和物件遍歷

技術標籤：內的 物件 獲取 鍵值對 題記 接著上一篇文章說一說陣列遍歷和物件遍歷

藍橋杯第三次培訓之圖的深度遍歷和廣度遍歷

技術標籤：藍橋杯演算法dfs圖論 圖的遍歷 圖的遍歷是指從圖中某一個頂點出發訪遍圖中其餘頂點，且使每一個頂點僅被訪問一次 圖的遍歷演算法是求解圖的連通性問題、拓撲排序和求關鍵路徑等演算法的基礎 由於圖結構

物件的廣度遍歷和深度遍歷

陣列的遍歷有多種方法，也有多種形式。 物件的遍歷除了for in，當物件資料多層巢狀時候，遍歷的方式又可以分深度優先遍歷和廣度優先遍歷。那麼怎麼實現呢？

js陣列遍歷和物件遍歷

針對js各種遍歷作一個總結分析，從型別用處：分陣列遍歷和物件遍歷；還有效能，優缺點等。

重新整理資料結構與演算法(c#)—— 圖的深度遍歷和廣度遍歷[十一]

參考網址：https://www.cnblogs.com/aoximin/p/13162635.html 前言 簡介圖: 在資料的邏輯結構D=（KR）中，如果K中結點對於關係R的前趨和後繼的個數不加限制，即僅含一種任意的關係，則稱這種資料結構為圖形結構。

個人自學前端42-雜談-vue中樹的深度遍歷和廣度遍歷

目錄 一. 深度遍歷 二. 廣度遍歷 一. 深度遍歷 // res 遍歷的陣列，id 判斷條件 console.log(this.setMenuId(res,id))

python和pywin32實現視窗查詢、遍歷和點選的示例程式碼

Pywin32是一個Python庫，為python提供訪問Windows API的擴充套件，提供了齊全的windows常量、介面、執行緒以及COM機制等等。

資料結構（樹）-由二叉樹的中序遍歷和後序遍歷序列構建對應的二叉樹

首先，對於給定二叉樹遍歷序列，如果只有前序遍歷、後序遍歷、中序遍歷的任意一個，無法唯一確定一棵二叉樹。舉個反例，如果給定二叉樹前序序列AB，則該二叉樹可以以A為根，B為左子樹，也可以以A為根，B為右子樹。這

入某二叉樹的前序遍歷和中序遍歷的結果，請重建該二叉樹。假設輸入的前序遍歷和中序遍歷的結果中都不含重複的數字。

輸入某二叉樹的前序遍歷和中序遍歷的結果，請重建該二叉樹。假設輸入的前序遍歷和中序遍歷的結果中都不含重複的數字。

Java List和Map遍歷的方法,forEach()的使用

注意: 不要在foreach迴圈裡進行元素的remove/add操作。remove元素請使用Iterator方式，如果併發操作，需要對Iterator物件加鎖。

dfs和bfs遍歷圖

3、遍歷 bfs ： Breadth first search 思路： 和二叉樹的層序遍歷很像，應用佇列，一層一層的遍歷

pikachu靶場——目錄遍歷和敏感資訊洩露

目錄遍歷 概述 在web功能設計中,很多時候我們會要將需要訪問的檔案定義成變數，從而讓前端的功能便的更加靈活。 當用戶發起一個前端的請求時，便會將請求的這個檔案的值(比如檔名稱)傳遞到後臺，後臺再執行其對應的

介紹下深度優先遍歷和廣度優先遍歷，如何實現？

什麼是深度優先和廣度優先 其實簡單來說 深度優先就是自上而下的遍歷搜尋 廣度優先則是逐層遍歷, 如下圖所示

二叉樹：前序遍歷，中序遍歷，後序遍歷和層序遍歷

用C/C++編寫二叉樹的前序遍歷，中序遍歷，後序遍歷（遞迴） 使用輔助佇列的層序遍歷（非遞迴）

LeetCode105 從前序遍歷和中序遍歷構造二叉樹

根據一棵樹的前序遍歷與中序遍歷構造二叉樹。 遞迴，根據前序遍歷當前有效區域第一個，即為當前根節點；找到中序遍歷中它的位置，左側為左節點，右側為右節點。

二叉樹的深度優先遍歷和廣度優先遍歷

深度優先遍歷（棧，先壓右節點，再壓左節點） 也就深入的遍歷，沿著每一個分支直到走到最後，然後才返回來遍歷剩餘的節點。二叉樹不同於圖，圖需要標記節點是否已經訪問過，因為可能會存在環，而二叉樹不會出現環，所

圖的深度優先遍歷和廣度優先遍歷

深度優先遍歷是縱向遍歷，一直到底，二叉樹的前序遍歷、中序遍歷，後序遍歷都是深度優先遍歷。　　

佇列和棧遍歷樹Mark一下

/// <summary> /// 廣度遍歷樹，並給其編碼 /// </summary> /// <param name="T"></param>