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")))  //这里改成if(!(it.next().equals("abc")))
                                        {
                                                al1.add(s);  // 这里 改成al1(it.next());为什么答案就是不一样的 求解释。。。。。。。。。。。我感觉2个代码都是同一个意思啊
                                        }
                                 }
                                 return al1;
        }
}
  

        

it.next()是返回迭代器中的下一个元素，每执行一次取得的元素不是同一个

额 你的意思 第二种写法  会漏掉一些值是么

1. while (it.hasNext())
   
2.     {
   
3.           String s = it.next();  // 这句话的意思是将迭代的值赋值给s  
   
4.           if (!(s.equals("abc")))  //这里是拿s的值进行比较，迭代器每次取值不同，如果改成it.next()就会再取得下一个值然后进行比较，并非你想要的那个值
   
5.           {
   
6.                   al1.add(s);  // 如果这里也写成it.next()的话就又会取下一个值，所以最后得出的结果不同
   
7.            }
   
8.     }
   
9.     return al1;

复制代码

张海涛 发表于 2012-12-11 01:36

写的真好 赞一个完全明白了

1. 针对楼主问题总结如下解决方案 ，看官们请过目 ：

复制代码

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

复制代码