问题如下

import java.util.*;

/*
去除ArrayList集合中的重复元素。

*/

class ArrayListTest
{

        public static void sop(Object obj)
        {
                System.out.println(obj);
        }
        public static void main(String[] args)
        {
                ArrayList al = new ArrayList();  //此处已经定义一个容器，并且在下面已经加入元素

                al.add("java01");
                al.add("java02");
                al.add("java01");
                al.add("java02");
                al.add("java01");
//                al.add("java03");


                /*
                在迭代时循环中next调用一次，就要hasNext判断一次。
                Iterator it = al.iterator();

                while(it.hasNext())
                {
                        sop(it.next()+"...."+it.next());
                }
                */

                /**/
                sop(al);
               
                al = singleElement(al);//此处经过过滤后的返回值又放到这个al里，这个al应该还是原来的al吧。他们之间不会重复吗？以前的那些数据会被删除了再来添加过滤后的元素吗？

                sop(al);
               

        }

        public static ArrayList singleElement(ArrayList al)
        {
                //定义一个临时容器。
                ArrayList newAl = new ArrayList();

                Iterator it = al.iterator();

                while(it.hasNext())
                {
                        Object obj = it.next();

                        if(!newAl.contains(obj))
                                newAl.add(obj);

                }

                return newAl;
        }
}

你这singleElement()方法遍历了整个原来的ArrayList集合，取出每一位，去除了相同的元素，添加到一个新的ArrayList中，方法结束后，newAl对象按理会在内存中消失。所以al指向null。是java不允许的

但由于singleElement()方法是静态的，所以会和类同在。
于是al在内存中还是指向了这个新的ArrayList

版主新上任，明察了，对于楼主的问题，第一个问题重复问题，想下程序走的流程就知道了，不会重复了，singleElement函数走完后，就会返回一新的集合，后来只是把al引用重新指给newAl祂，这个容器。第二个问题，没有删除，原理是这样的吧，把al集合传入singleElement里面是吧，里面又有个新集合是吧，这个先把传进来的集合里面的元素进行遍历，遍历过程中，拿新集合进行contains判断，如果有不存，如果没有存入，然后返回新集合在并指向al，这个时候，al其实是另外个集合，只是指向变了。

al = singleElement(al);//此处经过过滤后的返回值又放到这个al里，这个al应该还是原来的al吧。他们之间不会重复吗？以前的那些数据会被删除了再来添加过滤后的元素吗？
//这个al已经不是原来的那个al了，这个al的值已经改变了并且指向了一个新的集合，原来的集合并没有改变，而是原来的集合的引用al发生了改变从而
  使得原来的集合没有了引用值，所以原来的集合在内存中变成了垃圾。如下图：

ArrayList al = new ArrayList();  //此处已经定义一个容器，并且在下面已经加入元素

                al.add("java01");
                al.add("java02");
                al.add("java01");
                al.add("java02");
                al.add("java01");
//                al.add("java03");
相当于是在栈内存中创建了一个al，并在堆内存中出创建了一个集合分配一个地址值，将地址值赋给al，使al指向该集合。之后给集合添加了元素。定义一个
ArrayList a= singleElement(al)使用后返回的是一个集合。即是一个新的集合，分配一个地址值，将地址值赋给a。 al = singleElement(al) 即是al=a，指的是将a的地址值赋给al，所以现在的al和之前al 的指向不同了。如楼上的图

两个al肯定不一样了，你用singleElement()方法遍历了原来的ArrayList，去掉相同的元素，添加到一个新的ArrayList中。
这是al在内存中指向了第二个ArrayList

按照我的理解这样写就是使用新的集合singleElement(al)为原有的集合变量al重新赋值，这个的变量不过就是接收了一下,如果为了看得清晰，也可以重新定义一个新的ArrayList的变量来接收他；
import java.util.ArrayList;
import java.util.Iterator;
class Demo1
{

        public static void main(String[] args)
        {
                ArrayList al = new ArrayList();  //此处已经定义一个容器，并且在下面已经加入元素
                al.add("java01");
                al.add("java02");
                al.add("java01");
                al.add("java02");
                al.add("java01");
//                al.add("java03");

                /*
                在迭代时循环中next调用一次，就要hasNext判断一次。
                Iterator it = al.iterator();
                while(it.hasNext())
                {
                        sop(it.next()+"...."+it.next());
                }
                */
                /**/
                sop(al);
               
            //    al = singleElement(al);不要他；或者你自己在重新定义一个ArrayList来接收singleElement(al)
                //此处经过过滤后的返回值又放到这个al里，这个al应该还是原来的al吧。他们之间不会重复吗？以前的那些数据会被删除了再来添加过滤后的元素吗？
                sop(singleElement(al));
               
        }
        public static void sop(Object obj)
        {
                System.out.println(obj);
        }
        public static ArrayList singleElement(ArrayList al)
        {
                //定义一个临时容器。
                ArrayList newAl = new ArrayList();
                Iterator it = al.iterator();
                while(it.hasNext())
                {
                        Object obj = it.next();
                        if(!newAl.contains(obj))
                                newAl.add(obj);
                }
                return newAl;
        }
}

楼主，这个题的思想很重要，去除Arraylist中的重复元素，可以再创建一个新的集合，这个集合就是你要装最后不重复元素的集合，楼主这个做法其实是有点转弯了，不过也可以，题目中的al指向变了，你最开始那个集合变成垃圾了。这个创建新集合去解决一些问题的思路很重要，就像我要将你集合中的元素倒着排序，是不是也要新建一个集合呢，用来装倒叙后的元素啊

1. import java.util.*;
   
2. 
   
3. /*
   
4. 去除ArrayList集合中的重复元素。
   
5. 
   
6. */
   
7. 
   
8. class ArrayListTest
   
9. {
   
10. 
    
11.         public static void sop(Object obj)
    
12.         {
    
13.                 System.out.println(obj);
    
14.         }
    
15.         public static void main(String[] args)
    
16.         {
    
17.                 ArrayList al = new ArrayList();  //此处已经定义一个容器，并且在下面已经加入元素
    
18. 
    
19.                 al.add("java01");
    
20.                 al.add("java02");
    
21.                 al.add("java01");
    
22.                 al.add("java02");
    
23.                 al.add("java01");
    
24. //                al.add("java03");
    
25. 
    
26. 
    
27.                 /*
    
28.                 在迭代时循环中next调用一次，就要hasNext判断一次。
    
29.                 Iterator it = al.iterator();
    
30. 
    
31.                 while(it.hasNext())
    
32.                 {
    
33.                         sop(it.next()+"...."+it.next());
    
34.                 }
    
35.                 */
    
36. 
    
37.                 /**/
    
38.                 sop(al);
    
39.                 //因为al改变了指向  所以原来的集合会被堆内存的垃圾回收机制当作垃圾被不定时的回收
    
40.                 al = singleElement(al);//这里al为一个引用变量，它指向了newAl所指向的集合  
    
41.                                                        //这样就实现了将重复元素去除的功能
    
42. 
    
43.                sop(al);
    
44.                                 }
    
45.                
    
46. 
    
47.         }
    
48. 
    
49.         public static ArrayList singleElement(ArrayList al)
    
50.         {
    
51.                 //定义一个临时容器。
    
52.                 ArrayList newAl = new ArrayList();
    
53. 
    
54.                 Iterator it = al.iterator();
    
55. 
    
56.                 while(it.hasNext())
    
57.                 {
    
58.                         Object obj = it.next();
    
59. 
    
60.                         if(!newAl.contains(obj))//在这里调用了contains方法 判断newAl指向的集合是否包含指定的元素，
    
61.                                                                         //如果不包含就将元素放入newAl中
    
62.                                 newAl.add(obj)；//将不包含的元素放入newAl指向的集合中；
    
63. 
    
64.                 }
    
65. 
    
66.                 return newAl;//返回的就是一个新的不包含重复元素的集合的引用
    
67.         }
    
68. }
    

复制代码