java遍歷刪除list

A. java哪個list可以遍歷的時候刪除元素

遍歷的時候想要刪除元素就使用queue或者stack，不要使用list。list作為列表的數據結構在遍歷期間是不允許進行變動的。

B. 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);
}
}

C. java中list的遍歷有幾種方式

1.使用索引（index）來遍歷List
2.使用Iterator來遍歷List。（for-each其實也是利用Iterator）
注意：如果僅僅是遍歷，那麼可以可以使用索引或Iterator來遍歷。但是，如果你在遍歷的同時還要刪除元素，則最好使用Iterator來遍歷和刪除元素，這樣可以避免異常。

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

主要有三種方法：

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

   

E. java中 foreach 和迭代器在遍歷 List 集合 一些情況下為什麼能使用集合自動的刪除方法刪除元素

你a<70的時候是倒數第二位，也就是66，沒有拋出異常是因為之前list大小為5，你刪除66後，list大小為4，你第一次遍歷list大小為5的數組的時候，66的cursor在index ＝ 4，當你刪除後，遍歷list大小為4的數組時， cursor ＝ 4 ＝ newlist.size()。

ArrayList里的這個方法就會判斷list已經讀取完畢了，所以不會拋出異常。

publicbooleanhasNext(){
returncursor!=size;
}

a < 90的時候在第二位就發生了變化，list的大小也發生了變化

看了下ArrayList的源碼，每次循環的時候都會call這個方法檢查list的大小是否發生了變化，但是這個方法是發生在hasNext方法之後的

(){
if(modCount!=expectedModCount)
();
}

F. Java中遍歷ArrayList的過程中刪除元素操作會發生並發修改異常

首先搞清楚不是x=n-1不報錯。是因為他避開了錯誤，實際當你用倒數第2個來刪除的時候，他就已經跳出循環，不會判斷最後以為，這是為什麼呢？

我們先看看加強for循環是怎麼實現的。都知道是通過迭代實現，那麼將for寫成迭代器來看。

Iterator<Object>itr=al.iterator();
while(itr.hasNext()){
Objecto=itr.next();
System.out.println(itr.hasNext());
if("n".equals(o)){
al.remove(o);
}
}

以上就是加強for循環的真正樣子。再來透析源代碼。

al.iterator():返回一個迭代器沒什麼好說的；

itr.hasNext():通過判斷cursor（游標） != size（長度）來決定是否結束循環,cursor（游標） 初始是0 每次經過itr.next() +1；當cursor==size時 會跳出循環,這也是為什麼倒數第2個不會出錯的主要原因;

itr.next(): 看源代碼可以發現每次在next()調用後，都會先調用checkForComodification()這個方法；

checkForComodification()： 主要作用是判斷itr迭代器數據是否和list一致，

有兩個參數，

第一個modCount 集合結構變動次數，如：一開始你add調用了7次，那麼這個數就是7，

第二個expectedModCount 在調用iterator()方法時，初始化值等於modCount ，

這個方法判斷當modCount ！=expectedModCount 時

拋出異常，如果你調用迭代器的remove方法，expectedModCount 會重新賦值，但是你調用的是list的remove方法，那麼modCount 就會+1 而expectedModCount 不變，這就會造成modCount ！=expectedModCount；

最後，看看為什麼倒數第2個不會拋異常：

當他遍歷到「n-1」時，cursor=6，然後調用remover(o)方法，size=6，這個時候調用了itr.hasNext()判斷cursor是否等於size，前面說過，當cursor==size時，跳出循環，那麼就不會進入next(),也就不會進入checkForComodification()方法，所以不會拋出異常，說白了，也就是循環次數少了一次。

結合著源碼看，應該會比較清晰。

G. 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;
}
}

H. java中對集合對象list的幾種循環訪問總結

List一共有三種遍歷方法，如下：

importjava.util.ArrayList;
importjava.util.Iterator;
importjava.util.List;

publicclassMain{
publicstaticvoidmain(String[]args){
List<Integer>list=newArrayList<>();
for(inti=0;i<10;i++){
list.add(i);
}

//for循環遍歷
for(inti=0,size=list.size();i<size;i++){
System.out.println(list.get(i));
}

//iterator迭代器遍歷
Iterator<Integer>it=list.iterator();
while(it.hasNext()){
System.out.println(it.next());
}

//foreach循環
for(Integeri:list){
System.out.println(i);
}
}
}

數據元素是怎樣在內存中存放的？

主要有2種存儲方式：

1、順序存儲，Random Access（Direct Access）：

這種方式，相鄰的數據元素存放於相鄰的內存地址中，整塊內存地址是連續的。可以根據元素的位置直接計算出內存地址，直接進行讀取。讀取一個特定位置元素的平均時間復雜度為O(1)。正常來說，只有基於數組實現的集合，才有這種特性。Java中以ArrayList為代表。

2、鏈式存儲，Sequential Access：

這種方式，每一個數據元素，在內存中都不要求處於相鄰的位置，每個數據元素包含它下一個元素的內存地址。不可以根據元素的位置直接計算出內存地址，只能按順序讀取元素。讀取一個特定位置元素的平均時間復雜度為O(n)。主要以鏈表為代表。Java中以LinkedList為代表。

每個遍歷方法的實現原理是什麼？

1、傳統的for循環遍歷，基於計數器的：

遍歷者自己在集合外部維護一個計數器，然後依次讀取每一個位置的元素，當讀取到最後一個元素後，停止。主要就是需要按元素的位置來讀取元素。

2、迭代器遍歷，Iterator：

每一個具體實現的數據集合，一般都需要提供相應的Iterator。相比於傳統for循環，Iterator取締了顯式的遍歷計數器。所以基於順序存儲集合的Iterator可以直接按位置訪問數據。而基於鏈式存儲集合的Iterator，正常的實現，都是需要保存當前遍歷的位置。然後根據當前位置來向前或者向後移動指針。

3、foreach循環遍歷：

根據反編譯的位元組碼可以發現，foreach內部也是採用了Iterator的方式實現，只不過Java編譯器幫我們生成了這些代碼。

各遍歷方式的適用於什麼場合？

1、傳統的for循環遍歷，基於計數器的：

順序存儲：讀取性能比較高。適用於遍歷順序存儲集合。

鏈式存儲：時間復雜度太大，不適用於遍歷鏈式存儲的集合。

2、迭代器遍歷，Iterator：

順序存儲：如果不是太在意時間，推薦選擇此方式，畢竟代碼更加簡潔，也防止了Off-By-One的問題。

鏈式存儲：意義就重大了，平均時間復雜度降為O(n)，還是挺誘人的，所以推薦此種遍歷方式。

3、foreach循環遍歷：

foreach只是讓代碼更加簡潔了，但是他有一些缺點，就是遍歷過程中不能操作數據集合（刪除等），所以有些場合不使用。而且它本身就是基於Iterator實現的，但是由於類型轉換的問題，所以會比直接使用Iterator慢一點，但是還好，時間復雜度都是一樣的。所以怎麼選擇，參考上面兩種方式，做一個折中的選擇。

I. java 中一個list循環list一段數據中某幾位如果相同則去掉，這個怎麼處理

你可以把已遍歷的對象唯一識別碼放入map，每次遍歷下一個的時候，獲取當前遍歷的對象識別碼，用作map的key，看看是否已經存在map中，如果存在就移除集合當前的對象，如果不存在，就仍舊放入map中，大致代碼片段如下：
Map<String,
Integer>
uniqueMap
=
new
HashMap<String,
Integer>();
while(i<
list.size()){
Man
m
=
list.get(i)
if(uniqueMap
.get(m.getName())
!=
null){
list.remove(i);
//這里因為移除了一個，所以遍歷序號不需要增加
}else{
uniqueMap
.put(m.getName(),
0);
i
++;
//這里因為沒有移除，所以序號正常增加
}
}

J. 如何從Java List中取出前100的數據並且刪除掉

java List中取出前100的數據並且刪除掉，遍歷list集合，把數據取出存到新集合，再刪除掉，如下方法：

packagecom.test;

importjava.util.ArrayList;

importjava.util.List;

publicclassTestA{

publicstaticvoidmain(String[]args){

//定義集合

List<String>list=newArrayList<String>();

//給集合存150個值

for(intx=1;x<=101;x++){

list.add("a"+x);

}

System.out.println("原集合內容："+list);

List<String>list2=newArrayList<String>();

//循環獲取和移除掉100值

for(intx=0;x<1;x++){

//獲取

Stringa=list.get(x);

list2.add(a);

//移除

list.remove(a);

//list2集合夠100則跳出循環

if(list2.size()==100){

break;}

//移除掉list集合一個元素，長度減一，標量應該不變所以減一，後面會x++

x--;}

System.out.println("取出的100值:"+list2);

//輸出剩下的值

System.out.println("剩下的list值："+list);}