public static void main(String[] args) {

                String s1="abc";
                String s2="abcd";
                String s3="abcdfd";
                String s4="abc";
                String s5="abwwcd";
                String s6="abcder";
                String s7="abc";

                ArrayList<String> aList=new ArrayList<String>();

                aList.add(s1);
                aList.add(s2);
                aList.add(s3);
                aList.add(s4);
                aList.add(s5);
                aList.add(s6);
                aList.add(s7);

                show(aList);

        System.out.println(aList);
        }

       
        public static void show(ArrayList aList){
               
        Iterator<String> it=aList.iterator();
       
        try{       



               
                while(it.hasNext()){

                String str=it.next();

                if("abc".equals(str)){

                       
                        aList.remove(str);
                       
                        show(aList);//为什么要用递归?
                }
        }
       
        }catch(Exception e){
               
        }
}
}

问什么要用递归啊,  不是有while循环么? 循环一次 如果有abc 就删除  用迭代器遍历而不用递归该怎么改?

用iterator的方法
import java.util.*;
class Lun
{
        public static void main(String[] args)
         {
                String s1="abc";
                String s2="abcd";
                String s3="abcdfd";
                String s4="abc";
                String s5="abwwcd";
                String s6="abcder";
                String s7="abc";
                ArrayList<String> al=new ArrayList<String>();
                al.add(s1);
                al.add(s2);
                al.add(s3);
                al.add(s4);
                al.add(s5);
                al.add(s6);
                al.add(s7);
                                System.out.println("原集合"+al);
                                al=getNewElements(al);
             System.out.println(al);
        }
         public static ArrayList<String> getNewElements(ArrayList<String> al)
        {
                 ArrayList<String> al1= new ArrayList<String>();
                                 Iterator<String> it=al.iterator();
                                 while (it.hasNext())
                                 {
                                        String s=it.next();
                                        if (!(s.equals("abc")))
                                        {
                                                al1.add(s);
                                        }
                                 }
                                 return al1;
        }
}
  

        
        这题目用递归明显是代码变少了吧？

1. package com.itheima.chendonglian3;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.Iterator;
   
5. import java.util.List;
   
6. import java.util.ListIterator;
   
7. 
   
8. /**
   
9. * 楼主的问题我不得不说几句了 ，
   
10. *首先，字符串有必要声明后添加到集合吗 ？！
    
11. *再者，针对楼主的问题我提供如下的解决方案 ，各位看官请过目：
    
12. * 一个ArrayList对象aList对象中存在若干个字符串元素，现欲遍历该ArrayList对象，删除其中所有值为"abc"的字符串元素
    
13. *
    
14. */
    
15. public class ArrayListTest {
    
16. public static void main(String[] args) {
    
17. System.out.println("--------第一种------------");
    
18. removeByFor();
    
19. System.out.println("--------第二种------------");
    
20. removeByIterator1();
    
21. System.out.println("--------第三种-----------------------");
    
22. removeByIterator2();
    
23. System.out.println("--------第四种-----------------------");
    
24. removeByListIterator();
    
25. System.out.println("----第五种增强for循环仅限于查询-------");
    
26. queryByForEach();
    
27. }
    
28. /*
    
29. * 使用一般for直接对集合进行删除
    
30. */
    
31. public static void removeByFor() {
    
32. List<String> aList = new ArrayList<String>();
    
33. aList.add("abc");
    
34. aList.add("abcd");
    
35. aList.add("abcde");
    
36. aList.add("abc");
    
37. System.out.println("删除前：" + aList);
    
38. for (int i = 0; i < aList.size(); i++) {
    
39. if ("abc".equals(aList.get(i))) {
    
40. aList.remove(i);
    
41. }
    
42. 
    
43. }
    
44. System.out.println("删除后：" + aList);
    
45. }
    
46. /*
    
47. * 使用迭代器的remove()方法一
    
48. */
    
49. public static void removeByIterator1() {
    
50. List<String> aList = new ArrayList<String>();
    
51. aList.add("abc");
    
52. aList.add("abcd");
    
53. aList.add("abcde");
    
54. aList.add("abc");
    
55. System.out.println("删除前：" + aList);
    
56. for (Iterator<String> it = aList.iterator(); it.hasNext();) {
    
57. String str = it.next();
    
58. if (str.equals("abc")) {
    
59. it.remove();
    
60. }
    
61. }
    
62. System.out.println("删除后：" + aList);
    
63. }
    
64. /*
    
65. * 使用迭代器的remove()方法二
    
66. */
    
67. public static void removeByIterator2() {
    
68. List<String> aList = new ArrayList<String>();
    
69. aList.add("abc");
    
70. aList.add("abcd");
    
71. aList.add("abcde");
    
72. aList.add("abc");
    
73. System.out.println("删除前:" + aList);
    
74. Iterator<String> it = aList.iterator();
    
75. while (it.hasNext()) {
    
76. String str = it.next();
    
77. if (str.endsWith("abc"))
    
78. it.remove();
    
79. }
    
80. System.out.println("删除后：" + aList);
    
81. }
    
82. 
    
83. /*
    
84. * 使用列表迭代器 。ListIterator接口
    
85. */
    
86. public static void removeByListIterator() {
    
87. List<String> aList = new ArrayList<String>();
    
88. aList.add("abc");
    
89. aList.add("abcd");
    
90. aList.add("abcde");
    
91. aList.add("abc");
    
92. System.out.println("删除前" + aList);
    
93. ListIterator<String> li = aList.listIterator();
    
94. while (li.hasNext()) {
    
95. String str = li.next();
    
96. if (str.equals("abc")) {
    
97. li.remove();
    
98. }
    
99. }
    
100. System.out.println("删除后" + aList);
     
101. 
     
102. }
     
103. /*
     
104. * 增强for循环查询,但是不能对遍历的元素进行增、删、改操作 。
     
105. */
     
106. public static void queryByForEach() {
     
107. List<String> aList = new ArrayList<String>();
     
108. aList.add("abc");
     
109. aList.add("abcd");
     
110. aList.add("abcde");
     
111. aList.add("abc");
     
112. 
     
113. Object[] obj = aList.toArray();
     
114. for (Object o : obj) {
     
115. String str = (String) o;
     
116. if ("abc".equals(str)) {
     
117. System.out.println("遍历出符合条件的元素是："+str);
     
118. }
     
119. }
     
120. }
     
121. 
     
122. }

复制代码

这代码真心有问题，在iterator迭代时不能修改集合中的元素，否则会抛异常，使用递归无非是在catch到异常后再继续执行，而且catch块中什么都没写，表面看起来达到效果了。
还是改成for循环吧，不要用iterator了