java遍历删除

1. java List遍历方法及其效率对比

Java代码

package zbalpha test;

import java util ArrayList;

import java util Iterator;

import java util List;

public class ListTest {

public static void main(String args[]){

List<Long> lists = new ArrayList<Long>();

for(Long i= l;i< l;i++){

lists add(i);

}

Long oneOk = oneMethod(lists);

Long oOk = oMethod(lists);

Long threeOk = threeMethod(lists);

Long fourOk = fourMethod(lists);

System out println( One: + oneOk);

System out println( Two: + oOk);

System out println( Three: + threeOk);

System out println( four: + fourOk);

}

public static Long oneMethod(List<Long> lists){

Long timeStart = System currentTimeMillis();

for(int i= ;i<lists size();i++) {

System out println(lists get(i));

}

Long timeStop = System currentTimeMillis();

return timeStop timeStart ;

}

public static Long oMethod(List<Long> lists){

Long timeStart = System currentTimeMillis();

for(Long string : lists) {

System out println(string);

}

Long timeStop = System currentTimeMillis();

return timeStop timeStart ;

}

public static Long threeMethod(List<Long> lists){

Long timeStart = System currentTimeMillis();

Iterator<Long> it = erator();

while (it hasNext())

{

System out println(it next());

}

Long timeStop = System currentTimeMillis();

return timeStop timeStart ;

}

public static Long fourMethod(List<Long> lists){

Long timeStart = System currentTimeMillis();

for(Iterator<Long> i = erator(); i hasNext();) {

System out println(i next());

}

Long timeStop = System currentTimeMillis();

return timeStop timeStart ;

}

}

容器类可以大大提高编程效率和编程能力 在Java 中 所有的容器都由SUN公司的Joshua Bloch进行了重新设计 丰富了容器类库的功能

Java 容器类类库的用途是 保存对象 它分为两类

Collection 一组独立的元素 通常这些元素都服从某种规则 List必须保持元素特定的顺序 而Set不能有重复元素

Map 一组成对的 键值对 对象 即其元素是成对的对象 最典型的应用就是数据字典 并且还有其它广泛的应用 另外 Map可以返回其所有键组成的Set和其所有值组成的Collection 或其键值对组成的Set 并且还可以像数组一样扩展多维Map 只要让Map中键值对的每个 值 是一个Map即可

迭代器

迭代器是一种设计模式 它是一个对象 它可以遍历并选择序列中的对象 而开发人员不需要了解该序列的底层结构 迭代器通常被称为 轻量级 对象 因为创建它的代价小

Java中的Iterator功能比较简单 并且只能单向移动

( ) 使用方法iterator()要求容器返回一个Iterator 第一次调用Iterator的next()方法时 它返回序列的第一个元素

( ) 使用next()获得序列中的下一个元素

( ) 使用hasNext()检查序列中是否还有元素

( ) 使用remove()将迭代器新返回的元素删除

Iterator是Java迭代器最简单的实现 为List设计的ListIterator具有更多的功能 它可以从两个方向遍历List 也可以从List中插入和删除元素

List的功能方法

List(interface): 次序是List最重要的特点 它确保维护元素特定的顺序 List为Collection添加了许多方法 使得能够向List中间插入与移除元素(只推荐 LinkedList使用) 一个List可以生成ListIterator 使用它可以从两个方向遍历List 也可以从List中间插入和删除元素

ArrayList: 由数组实现的List 它允许对元素进行快速随机访问 但是向List中间插入与移除元素的速度很慢 ListIterator只应该用来由后向前遍历ArrayList 而不是用来插入和删除元素 因为这比LinkedList开销要大很多

LinkedList: 对顺序访问进行了优化 向List中间插入与删除得开销不大 随机访问则相对较慢(可用ArrayList代替) 它具有方法addFirst() addLast() getFirst() getLast() removeFirst() removeLast() 这些方法(没有在任何接口或基类中定义过)使得LinkedList可以当作堆栈 队列和双向队列使用

Set的功能方法

Set(interface): 存入Set的每个元素必须是唯一的 因为Set不保存重复元素 加入Set的Object必须定义equals()方法以确保对象的唯一性 Set与Collection有完全一样的接口 Set接口不保证维护元素的次序

HashSet: 为快速查找而设计的Set 存入HashSet的对象必须定义hashCode()

TreeSet: 保持次序的Set 底层为树结构 使用它可以从Set中提取有序的序列

LinkedHashSet: 具有HashSet的查询速度 且内部使用链表维护元素的顺序(插入的次序) 于是在使用迭代器遍历Set时 结果会按元素插入的次序显示

lishixin/Article/program/Java/hx/201311/26494

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

3. 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()方法，所以不会抛出异常，说白了，也就是循环次数少了一次。

结合着源码看，应该会比较清晰。

4. JAVA中HashMap如何删除元素

HashMap删除元素根据其遍历方式一般有两种方法，实例演示如下：

一、采用foreach模式，适用于不需要修改HashMap内元素的遍历，只需要获取元素的键/值的情况。

1、遍历如下：

原因在于，迭代器遍历时，每一次调用 next() 函数，至多只能对容器修改一次。上面的代码则进行了两次修改：一次添加，一次删除。

5. java 多线程操作hashtable(添加，删除，遍历)

public class TestThread {
public static void main(String[] args){
Map<Integer, Object> tables = new Hashtable<Integer, Object>();
Thread add = new Thread(new ThreadAdd(tables));
Thread del = new Thread(new ThreadDel(tables));
Thread count = new Thread(new ThreadCount(tables));
//启动线程
add.start();
del.start();
count.start();
}
/**
*添加对象线程
*/
private static class ThreadAdd implements Runnable{
private Map<Integer, Object> table;

public ThreadAdd(Map<Integer, Object> tables){
this.table=tables;
}
public void run() {
// TODO Auto-generated method stub
for(int i=0;i<10;i++){
table.put(i, new Object());
System.out.println("添加对象,序号为:"+i);
}
}
}
/**
*删除对象线程
*/
private static class ThreadDel implements Runnable{
private Map<Integer, Object> table;

public ThreadDel(Map<Integer, Object> table){
this.table=table;
}
public void run() {
// TODO Auto-generated method stub
for(int i=0;i<10;i++){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
table.remove(i);
System.out.println("移除对象,序号为:"+i);
}
}
}
/**
*统计线程
*/
private static class ThreadCount implements Runnable{
private Map<Integer, Object> table;

public ThreadCount(Map<Integer, Object> table){
this.table=table;
}
public void run() {
// TODO Auto-generated method stub
for(int i=0;i<10;i++){
try {
Thread.sleep(50);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("当前队列还剩"+table.size()+"个对象");
}
}
}
}
这是我的写的demo，不知道符合不符合你的意思，大家共同交流共同进步。

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

7. java中的集合哪些可以边遍历边删除，哪些不可以，还有哪些可以边遍历边添加哪些不可以

都可以，关键是小心别越界了！

确切的说你应该注意遍历的方式和增删的方式是否一致（即：普通循环和迭代器别混合用）。

或者你的意思是有哪些集合是线程安全的，可两个线程一个遍历一个操作。这个api里有。
凡是自身是线程安全的都可以，不是就要自己实现线程安全，但还是小心别越界。

8. java用迭代器边遍历边删除的问题

if ((Integer.parseInt((String) it.next()) == 9)
|| (Integer.parseInt((String) it.next()) == 12)) {

你这个判断有问题，你执行了两次 next()方法。

这样改以下。

int i = Integer.parseInt((String) it.next();
if ((i == 9)|| (i == 12)) {

9. java：用Iterator遍历对象中,删除因元素不符合的对象,并显示出来

Vector<Student> stu = new Vector<Student>(6);
stu.add(new Student(1001,"张三"));
stu.add(new Student(1002,"李四"));
stu.add(new Student(1003,"王五"));
stu.add(new Student(1004,"赵六"));
stu.add(new Student(1005,"赵小宝"));
stu.add(new Student(1006,"张小明"));
Iterator<Student> iter = stu.iterator();
while(iter.hasNext()){
String s =iter.next().getName();
if(s.length()==3){
System.out.println(s);
iter.remove();
}
}