javalist循環刪除元素

⑴ java List 遍歷和刪除 急

List可以用序號來遍歷，但通常推薦使用iterator來遍歷
Iterator itr = list.iterator();
while (itr.hasNext()) {
Object nextObj = itr.next();
}

如果要全部刪除，用clear()方法是最簡單的。
另外，Iterator也帶有remove()方法，可以在遍歷的時候，根據一定條件來進行刪除。

示例：

import java.util.*;

public class Test {
public static void print(List<Integer> list) {
Iterator<Integer> itr = list.iterator();
while (itr.hasNext()) {
System.out.print(itr.next());
System.out.print(", ");
}
System.out.println();
}

public static void main(String[] args) {
List<Integer> s = new ArrayList<Integer>();
for (Integer i = 0; i < 10; i++) {
s.add(i);
}
print(s);

Iterator<Integer> itr = s.iterator();
while (itr.hasNext()) {
Integer i = itr.next();
if (i % 3 == 0) {
itr.remove();
}
}
print(s);
}
}

⑵ java遍歷list 並刪除相同值對象

用一個for循環遍歷List時，不能刪除其中的元素。

用Iterator操作即可。

還有 Pro類要重寫一下 toString方法。這樣System.out.println里才能列印出來。

import java.util.*;

public class ListTest {
public static void main(String[] args) {

List<Pro> list = new ArrayList();
Pro p1 = new Pro("1000","1000");
Pro p2 = new Pro("1001","1002");
Pro p3 = new Pro("1003","1004");
Pro p4 = new Pro("1005","1006");
list.add(p1);
list.add(p2);
list.add(p3);
list.add(p4);

for (Iterator<Pro> i = list.iterator(); i.hasNext();) {
Pro o = i.next();
if(o.getProid().equals(o.getProName())){
i.remove();
}
}
System.out.println(list);
}
}

class Pro{
private String proid;
private String proName;

public String getProid() {
return proid;
}
public void setProid(String proid) {
this.proid = proid;
}
public String getProName() {
return proName;
}
public void setProName(String proName) {
this.proName = proName;
}
public Pro(String proid, String proName) {
super();
this.proid = proid;
this.proName = proName;
}
public Pro() {
}

public String toString() {
return proid + ":" + proName;
}
}

⑶ java鎬庝箞鍒犻櫎涓涓闆嗗悎涓鐨勫厓緔

java涓闆嗗悎list鎻愪緵remove()鏂規硶鍒犻櫎闆嗗悎涓鐨勫厓緔 錛屼笉榪囬泦鍚堝拰鏁扮粍涓嶅悓錛屽傛灉鍒犻櫎闆嗗悎涓涓涓鍏冪礌錛屾ゅ厓緔犲悗闈㈢殑鍏冪礌涓嬫爣浼氬噺1 錛屾墍浠ュ傛灉鏄鍒犻櫎涓涓鎸囧畾鍏冪礌灝卞彲浠ョ洿鎺ュ垹闄list.remove(i)錛屽傛灉寰鐜鍒犻櫎鍏ㄩ儴鍏冪礌鍙浠ヤ竴鐩村垹闄や笅鏍囦負1鐨勫厓緔狅紝鍒犻櫎list.size()嬈★紱鎴栬呬粠鍚庡垹闄わ紝姣忔″垹闄ゅ氨鎶婁笅鏍囧噺1錛

⑷ java 怎麼刪除List中的指定元素

主要有三種方法：

1. 用一個List 記錄要刪除的數據,最後removeAll(List)；

   

⑸ HashMap和List遍歷方法總結及如何遍歷刪除

（一）List的遍歷方法及如何實現遍歷刪除
我們造一個list出來，接下來用不同方法遍歷刪除，如下代碼：
List<String> list= new ArrayList<String>();famous.add("zs");famous.add("ls");famous.add("ww");famous.add("dz");

1、for循環遍歷list：
for(int i=0;i<list.size();i++){if(list.get(i).equals("ls"))list.remove(i);}

這是一種很常見的遍歷方式，但是使用這種遍歷刪除元素會出現問題，原因在於刪除某個元素後，list的大小發生了變化，而你的索引
也在變化，所以會導致你在遍歷的時候漏掉某些元素。比如當你刪除第一個元素後，繼續根據索引訪問第二個元素後，因為刪除的原因，
後面的元素都往前移動了以為，所以實際訪問的是第三個元素。因此，這種遍歷方式可以用在讀取元素，而不適合刪除元素。
2、增強for循環：
for(String x:list){if(x.equals("ls"))list.remove(x);}

這也是一種很常見的遍歷方式，但是使用這種遍歷刪除元素也會出現問題，運行時會報異常
其實增強for循環是java語法糖的一種體現，如果大家通過反編譯得到位元組碼，那麼上面這段代碼的內部實現如下所示:

for(Iterator<String> it = list.iterator();it.hasNext();){String s = it.next();if(s.equals("madehua")){list.remove(s);}}

下面就解釋為什麼會報異常。分析Iterator的源代碼，重點分析整個調用該過程中的
函數（hasNext和remove）:

private class Itr implements Iterator<E> { int cursor; // index of next element to return int lastRet = -1; // index of last element returned; -1 if no such int expectedModCount = modCount; public boolean hasNext() { return cursor != size; // size為集合中元素的個數 } public E next() { checkForComodification(); int i = cursor; if (i >= size) throw new NoSuchElementException(); Object[] elementData = ArrayList.this.elementData; if (i >= elementData.length) throw new (); cursor = i + 1; return (E) elementData[lastRet = i]; } /* 此方法並沒被調用，只是調用List.remove方法 public void remove() { checkForComodification(); try { ArrayList.this.remove(lastRet); // size欄位減1 cursor = lastRet; lastRet = -1; expectedModCount = modCount; } catch (IndexOutOfBoundsException ex) { throw new (); } } */ final void checkForComodification() { // 檢查修改和當前版本號是否一致，不一致則拋出異常 if (modCount != expectedModCount) throw new (); } } // List.remove @Override public boolean remove(Object object) { Object[] a = array; int s = size; if (object != null) { for (int i = 0; i < s; i++) { if (object.equals(a[i])) { System.array(a, i + 1, a, i, --s - i); a[s] = null; // Prevent memory leak size = s; modCount++; // 核心代碼：修改了版本號。這樣當checkForComodification的時候，modCount值就和expectedModCount不同 return true; } } } else { for (int i = 0; i < s; i++) { if (a[i] == null) { System.array(a, i + 1, a, i, --s - i); a[s] = null; // Prevent memory leak size = s; modCount++; return true; } } } return false; }

接下來梳理一下流程，這時候你就會發現這個異常是在next方法的checkForComodification中拋出的。拋出的原因是
modCount !=expectedModCount。這里的modCount是指這個list對象從呢我出來到現在被修改的次數，當調用list
的add或者remove方法的時候，這個modCount都會自動增減；iterator創建的時候modCount被復制給了
expectedModcount，但是調用list的add和remove方法的時候不會同時自動增減expectedModcount，這樣就導致
兩個count不相等，從而拋出異常。大家如果理解了上面的執行流程，以後碰到類似這種問題，比如如果刪除的是倒數
第二個元素卻不會碰到異常。就會知道為什麼了。

3、iterator遍歷刪除：

Iterator<String> it = list.iterator();while(it.hasNext()){String x = it.next();if(x.equals("del")){it.remove();}}

這種方式是可以正常遍歷和刪除的。但是你可能看到上面代碼感覺和增強for循環內部實現的代碼差不多，其實差別就在於上面使用
一個使用list.remove(),一個使用it.remove()。

（二）HashMap的遍歷刪除及如何實現遍歷刪除
一樣我們先造一個hashmap出來，如下：

private static HashMap<Integer, String> map = new HashMap<Integer, String>();; public static void main(String[] args) { for(int i = 0; i < 10; i++){ map.put(i, "value" + i); } }

1、第一種遍歷刪除：

for(Map.Entry<Integer, String> entry : map.entrySet()){Integer key = entry.getKey();if(key % 2 == 0){System.out.println("To delete key " + key);map.remove(key);System.out.println("The key " + + key + " was deleted");}

這種遍歷刪除依舊會報異常，
2、第二種遍歷刪除：
Set<Integer> keySet = map.keySet(); for(Integer key : keySet){ if(key % 2 == 0){ System.out.println("To delete key " + key); keySet.remove(key); System.out.println("The key " + + key + " was deleted"); } }

這種遍歷刪除依舊會報異常，
3、第三種遍歷刪除：
Iterator<Map.Entry<Integer, String>> it = map.entrySet().iterator();while(it.hasNext()){Map.Entry<Integer, String> entry = it.next();Integer key = entry.getKey();if(key % 2 == 0){ System.out.println("To delete key " + key); it.remove(); System.out.println("The key " + + key + " was deleted");}}

這種遍歷是OK的
分析上述原因，如果大家理解了List的遍歷刪除，那麼感覺HashMap的遍歷刪除是不是有類似之處啊。下面就分析一下原因：
如果查詢源代碼以上的三種的刪除方式都是通過調用HashMap.removeEntryForKey方法來實現刪除key的操作。
在removeEntryForKey方法內知識一場了key modCount就會執行一次自增操作，此時modCount就與expectedModCOunt不一致了
，上面三種remove實現中，只有第三種iterator的remove方法在調用完removeEntryForKey方法後同步了expectedModCount值與
modCount相同，所以iterator方式不會拋出異常。最後希望大家遇到問題到查詢源代碼，它會給你最好的解釋！