由于ArrayList 的元素删除元素后长度变小了，元素的索引也会跟着改变，
但是迭代的下标没有跟着相应的改变。请问怎么处理在ArrayList中删除所有不等于指定值的元素?

楼主我给你一个例子你可以参考一下，是我自己写程序的时候做的。
先说一下思路吧。首先你的条件是去除ArrayList中你不希望出现的元素，那么直接修改肯定是做不到的。我的思路就是你可以重新建一个新的ArrayList，
然后将原来的arraylist中的元素抽出来挨个和你的条件进行对比，然后如果符合条件就做一些处理在添加到新的arrayList中去，如果不需要处理就直接添加
具体的实例代码如下：
public ArrayList<String> arrHandle(ArrayList<String> list,String deletStr)
        {
                //新建一个将来要返回的list
                ArrayList<String> blist = new ArrayList<String>();
                //遍历传进来的list
                for(int i = 0 ; i < list.size() ; i ++ )
                {
                        //得到的元素
                        String str = list.get(i);
                        StringBuilder sb = new StringBuilder(str);
                        //判断得到的元素是否含有deletStr,如果有就删除
                        if(str.contains(deletStr))
                        {
                                //将得到的每个元素拆分成char数组然后去挨个对比其中的元素
                                char[] c = str.toCharArray();
                                for(int j = 0 ; j < c.length-2 ; j ++)
                                {
                                        if(c[j]=='a'&&c[j+1]=='b'&&c[j+2]=='c')
                                        {
                                                sb.delete(j, j+2);
                                        }
                                }
                        }
                        //最后将重新组合的元素添加到blist中
                        blist.add(sb.toString());
                }
                return blist;
        }
这只是一个方法，不过还是很容易看懂的。

1. import java.util.ArrayList;
   
2. import java.util.Iterator;
   
3. 
   
4. public class Demo11 {
   
5. 
   
6.         /**
   
7.          *由于ArrayList 的元素删除元素后长度变小了，元素的索引也会跟着改变，
   
8.          *但是迭代的下标没有跟着相应的改变。请问怎么处理在ArrayList中删除所有不等于指定值的元素?
   
9.          */
   
10.         public static void main(String[] args) {
    
11.                 ArrayList<String> al = new ArrayList<String>();
    
12.                 al.add("aaa");
    
13.                 al.add("bbb");
    
14.                 al.add("bbb");
    
15.                 al.add("ccc");
    
16.                 al.add("ddd");
    
17.                 al.add("ddd");
    
18.                 al.add("aaa");
    
19.                 al.add("aaa");
    
20.                 al.add("eee");
    
21.                 System.out.println(al);/*删除前*/
    
22. 
    
23.                 Iterator<String> it = al.iterator();
    
24.                 while(it.hasNext()){
    
25.                         String str = it.next();
    
26.                         if(!(str.equals("eee"))){/*假设"eee是你说的指定值"*/
    
27.                                 it.remove();
    
28.                         }
    
29.                 }
    
30.                 System.out.println(al);/*删除后*/
    
31.         }
    
32. }

复制代码

这个很简单啊比较容易懂的就是你将那些你想删除的指定的值得索引给打印出来，然后再用arraylist的删除方法去删除不就行 了

为什么不考虑用ListInterator？可以在迭代过程中删除元素。
来自：黑马程序员训练营论坛 Android客户端来自: Android客户端

许涛 发表于 2012-7-1 01:05

这个方法专业

为什么要在ArrayList中删除所有不等于指定值的元素?

不知道是不是理解错误，若是删除所有不等于指定值的元素，即除了指定元素，其他都删除了？

那这样直接从集合取元素，再存到一个新的集合是可行。但是实际用处大吗？

如果指定元素只有一个，即原集合只保留一个元素。这种处理方式和新建一个指定元素（这个元素您已经知道）的集合或者数组来使用不更好。干嘛要从一个原集合中删除。

我确实想不到这样的情况。请指教？

给你另一张思路的解决方法。不足之处请斧正。
        List<String> list = new ArrayList<String>();//原有的元素列表
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        list.add("f");
        list.add("g");
        list.add("h");
        Set<String> set = new HashSet<String>();//需要删除的诸元素
        set.add("b");
        set.add("e");
        set.add("g");
        list.removeAll(set);//删除指定的元素集合
        System.out.println("打印剩下的元素："+list);

1. public static void main(String[] args)
   
2.     {
   
3.                 ArrayList<String> arr=new ArrayList<String>();
   
4.                 arr.add("zhangsan");
   
5.                 arr.add("lisi");
   
6.                 arr.add("wangwu");
   
7.                 arr.add("zhaoliu");
   
8.                 arr.add("qianba");
   
9.                 delItem(arr,"wangwu");
   
10.                 System.out.println(arr);
    
11.     }
    
12.        
    
13.         public static void delItem(ArrayList<String> arr,String delstr)
    
14.         {
    
15.                 int num=0;
    
16.                 while(num<arr.size())
    
17.                 {
    
18.                         for(int x=0;x<arr.size();x++)
    
19.                         {
    
20.                                 ListIterator<String> it=arr.listIterator(x);
    
21.                                 if(!it.next().equals(delstr))
    
22.                                 {
    
23.                                         it.remove();
    
24.                                         break;
    
25.                                 }
    
26.                                 num++;
    
27.                         }
    
28.                 }
    
29.         }

复制代码

public class Test2 {
        public static void main(String[] args) {
                ArrayList list = new ArrayList();
                list.add("abc");
                list.add("java");
                list.add("java");
                list.add("bcd");
                list.add("java");
                list.add("java");

                sop(list);
                removeList2(list);
                sop(list);


        }

        public static void sop(Object obj) {
                System.out.println(obj);
        }
        //方法一：
        public static void removeList1(List<String> list) {
                for (int i = 0; i < list.size(); i++) {
                        if ("java".equals(list.get(i))) {
                                list.remove(i);
                                --i;// 删除了元素，迭代的下标也跟着改变
                        }
                }
        }
//        方法二：
        public static void removeList2(List<String> list) {
                Iterator<String> iterator = list.iterator();
                while (iterator.hasNext()) {
                        String str = iterator.next();
                        if ("java".equals(str)) {
                                iterator.remove();
                        }

                }
        }
}
打印结果：
abc  bcd