红色的语句。我想知道返回的al就是new1了，为什么输出al还是以前的呢？

/*
去除ArrayList集合中的重复元素。
*/
import java.util.*;
class ArrayListTest
{
public static void main(String[] args)
{
  ArrayList al=new ArrayList();
  al.add("java01");
  al.add("java02");
  al.add("java03");
  al.add("java01");
singleArray(al);
  System.out.println(al);
}

public static ArrayList singleArray(ArrayList al)
{
  ArrayList new1=new ArrayList();
  Iterator it=al.iterator();
  while (it.hasNext())
  {
   Object obj=it.next();
   if (!new1.contains(obj))
   {
    new1.add(obj);
   }
  }
  System.out.println("hello");
al=new1;
   return al;
}
}

singleArray(al);//这句代码的返回值应该用一个变量接收一下，然后再打印这个变量
   System.out.println(al);
因为你的打印语句打印的是原集合的引用，当然是原集合的所有元素
有两种方式解决这个问题：
要么用一个变量接收函数的返回值，然后打印该变量如：
al=singleArray(al);
           System.out.println(al);
要么直接用打印语句打印如：
System.out.println(singleArray(al));
al=new1;
    return al;
此处直接return new1即可，不用赋值给al,没有什么用处。

刘士林 发表于 2012-11-7 07:39
singleArray(al);//这句代码的返回值应该用一个变量接收一下，然后再打印这个变量
   System.out.println(a ...

我知道怎么解决

我就想知道为何此al非彼al

package cn.itcast.heima;
import java.util.*;
class ArrayListTest {
public static void main(String[] args) {
  ArrayList al = new ArrayList();
  al.add("java01");
  al.add("java02");
  al.add("java03");
  al.add("java01");
  System.out.println(al);
  al = singleArray(al);    //这样就O了
  System.out.println(al);
}
public static ArrayList singleArray(ArrayList al) {
  ArrayList new1 = new ArrayList();
  Iterator it = al.iterator();
  while (it.hasNext()) {
   Object obj = it.next();
   if (!new1.contains(obj)) {
    new1.add(obj);
   }
  }
  al = new1;
  return al;
}
}

作用域，或者说传递概念不清晰　呜　推荐最好去重新看一下这方面的知识　我想你会明白的。

你这个程序的话　ArrayList al=new ArrayList();这个是在main里定义的，那么只在main里有他的作用域

对于singleArray(al)这个方法，你把上面的当作参数传递进去了，最后返回了这个方法的结果　但是这个结果并不是直接操作上面那个al，而是又新创了一个对象进行操作　返回的是这个新的对象的结果　你自己看看是不是。

这就相当于　我人在家里　然后要去奶奶家，但是我不知道路怎么走，就发了条短信给妈妈（引用过去），妈妈依照她的记忆给我发回了路线图，但是我本身还是在家里的，我并没有因为妈妈给了我路线图而直接传送到奶奶家去，最后还是需要我按照这个路线图自己走过去。

能明白么？

1. /*
   
2. 去除ArrayList集合中的重复元素。
   
3. */
   
4. import java.util.*;
   
5. class ArrayListTest
   
6. {
   
7. public static void main(String[] args)
   
8. {
   
9.    ArrayList al=new ArrayList();
   
10.    al.add("java01");
    
11.    al.add("java02");
    
12.    al.add("java03");
    
13.    al.add("java01");
    
14. singleArray(al);
    
15.    System.out.println(al);
    
16. }
    
17. 
    
18. public static ArrayList singleArray(ArrayList al)
    
19. {
    
20.    ArrayList new1=new ArrayList();
    
21.    Iterator it=al.iterator();
    
22.    while (it.hasNext())
    
23.    {
    
24.     Object obj=it.next();
    
25.     if (!new1.contains(obj))
    
26.     {
    
27.      new1.add(obj);
    
28.     }
    
29.    }
    
30.    System.out.println("hello");
    
31. al=new1;
    
32.     return al;
    
33. }
    
34. }

复制代码

下面的图是你这个代码中各引用变量指向的变化

你最后又把形参al的指向回al了，当然会是没消除重复之前的了

感觉这个是对于形参实参传递没有搞清楚了  方法中的al相当copy了一个al的地址值，当出了方法后，与外面的al就没有关系了。
因此若是对在方法中对al的地址改变了，是与外面的al没有关系的
import java.util.Arrays;
class Test1
{
        public static void main(String[] args)
        {
                int[] arr = {1,2,3,4,5};
                fuzhi(arr);
                System.out.println(Arrays.toString(arr));
        }

        public static void fuzhi(int[] arr)
        {
                arr[0] = 10;         //因为通过地址操作，因此改变了main函数的arr
                arr = new int[3];  //因为赋予了新的地址，因为对于main函数中的arr没有影响
               
        }
}

加一句就对了 al=singleArray(al);

因为你方法定义的就是去掉重复的元素，但是是通过另一个集合返回的。方法内部并没有删除原集合重复元素的操作。

并且你返回的集合你没有重新赋值。所以原集合变量指向没有变化。所以原集合没有变化。