关键词：collection,ArrayList,去重复      要求定义一个方法，去除ArrayList容器里面的重复元素（jre已定义的），思路是在方法中定义一个新的容器ArrayList，然后通过迭代，遍历需要去重复的容器里的元素，如果此元素没有被包括在新的容器里，那么就将此元素添加至新容器。反之，则不添加。最后，返回新容器。此时，容器内已经没有重复元素。
     在调试的时候，原来的思路是这么写的：
                  public static  ArrayList singleElement(ArrayList oldAL){
                          ArrayList newAL=new ArrayList();       //新建一个容器
                         for(ListIterator it=oldAL.listIterator();it.hasNext();){
                            Object e=it.next();
                            if(!newAL.contains(e))   {newAL.add(e);
                            }
                             return newAL;
                   }
测试结果正常。
        然后我将Object e=it.next(); if(!newAL.contains(e)) {newAL.add(e);}
                这两句试图修改为 if(!newAL.contains( it.next()) )  {newAL.add( it.next());}   居然也能运行，但得出的结论是错误的！
请问：这两句的区别在哪，1： it.next（）方法返回的是对象的实体么？还是对象的引用。用Object类的引用指向这个“实体”（或“引用”），用意何在？
                                         2：既然调用contain（）方法，传递参数e 是对的，写i传递参数it.next(）也没提示错误和警告，那么为什么运行后会出现不同的结果（丢失部分元素）
                                         3：用第二种写法时，改变旧容器数据，有时还会抛出异常。
源代码如下：测试的结果分别为


第一种
原来的容器[aaa, bbb, ccc, ddd, aaa, bbb]
去重复后的容器[aaa, bbb, ccc, ddd]
第二种

原来的容器[aaa, bbb, ccc, ddd, aaa, bbb]
去重复后的容器[bbb, ddd, bbb]

1. package collection.test;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.Collection;
   
5. //命题：去除容器内部的重复元素
   
6. //思路：定义一个新容器，从旧容器里轮流拿出元素与新容器里的元素相比，如果相同，就去除，不相同，就保留。
   
7. import java.util.ListIterator;
   
8. //方法功能：去除ArrayList中重复的元素(java已定义的元素)
   
9. 
   
10. 
    
11. public class Collection_ArrayList_text {
    
12.         @SuppressWarnings({ "rawtypes", "unchecked" })
    
13.         public static  ArrayList singleElement(ArrayList oldAL){
    
14.                 ArrayList newAL=new ArrayList();       //新建一个容器
    
15.                 for(ListIterator it=oldAL.listIterator();it.hasNext();){//迭代，遍历，contatins()方法=返回新容器
    
16.                         /*判断新容器中是否包含旧容器中的元素，
    
17.                          * 如果没有包含，
    
18.                          * 这将此元素添加至新容器中*/
    
19.                         //Object e=it.next();
    
20.                 //if(!newAL.contains(e))   {newAL.add(e);}       
    
21.                         if(!newAL.contains( it.next()) )  {newAL.add( it.next());}       
    
22. 
    
23.                 return newAL;
    
24.         }
    
25.         @SuppressWarnings({ "rawtypes", "unchecked" })
    
26.         public static void main(String[] args){
    
27.                 ArrayList al=new ArrayList();
    
28.                 al.add("aaa");
    
29.                 al.add("bbb");
    
30.                 al.add("ccc");
    
31.                 al.add("ddd");
    
32.                 al.add("aaa");
    
33.                 al.add("bbb");
    
34.                 System.out.println("原来的容器"+al);
    
35.                 System.out.println("去重复后的容器"+singleElement(al));       
    
36.     }
    
37. }
    
38.        
    
39.                
    
40.    
    
41. 
    
42. 
    
43. 
    
44. 
    
45. 
    
46. 
    
47. 
    
48. 
    
49. 
    
50. 
    
51. 
    
52. 
    
53. 
    
54. 
    
55. 
    
56. 
    
57. 
    
58. 
    
59. 
    
60. 
    
61. 
    
62. 
    
63. 
    
64. 
    
65. 
    
66. 
    

复制代码

我也是新手，就我的理解来讨论下
1、用OBJECT 是多态的用法
2、迭代器是一个容器，装的是引用，但是如果你it.next()一次，取出一个对象引用，但是同时又it.next()取出了再下一个对象引用，这2个it.next()取出的是不同的。
    oldAL.it()第一次取aaa 比较newAL里没有，然后你装了aaa的下一个元素bbb进newAL,然后你读ccc，判断new中没有,装了ddd,然后你取了aaa，判断new中没有，存了下一个bbb 就是这样
至于抛异常，可能是哪里语法不对把。

第21行  if(!newAL.contains( it.next()) )  {newAL.add( it.next());}      。。调用next了两次。newAL.contains( it.next())里的it.next()和newAL.add(it.next())里的it.next已经不是同一个元素了

rick1991chen 发表于 2015-5-6 19:48
我也是新手，就我的理解来讨论下
1、用OBJECT 是多态的用法
2、迭代器是一个容器，装的是引用，但是如果你i ...

嗯，有道理，正解