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