/*
请问怎么去掉重复元素？？
*/
import java.util.*;
class ArrayLIstTest
{
        public static void main(String[] args)
        {
                List list = new ArrayList();
                list.add("zhangsan");
                list.add("lisi");
                list.add("zhangsan");
                list.add("wangwu");
                list.add("zhangsan");
        
        }

}

1. import java.util.ArrayList;
   
2. import java.util.HashSet;
   
3. import java.util.List;
   
4. import java.util.Set;
   
5. 
   
6. class ArrayLIstTest
   
7. {
   
8.         public static void main(String[] args)
   
9.         {
   
10.                         // 最好加上参数类型  
    
11.                 List<String> list = new ArrayList<String>();
    
12.                 list.add("zhangsan");
    
13.                 list.add("lisi");
    
14.                 list.add("zhangsan");
    
15.                 list.add("wangwu");
    
16.                 list.add("zhangsan");
    
17.                
    
18.                 // 利用set的特性
    
19.                 Set<String> set = new HashSet<String>(list);
    
20.                
    
21.                 list = new ArrayList<String>(set);
    
22.                 System.out.println(list);
    
23.         }
    
24. 
    
25. }
    

复制代码

我想到两个办法 1、把集合遍历出来，remove（）重复元素。

2、把集合遍历出来，然后add()到 hashset 中 ，根据特性，自然去掉重复元素。

如果是一下这种情况，Student s1 = new Student("zhangsan");
                Student s2 = new Student("zhangsan");

                set.add(s1);
                set.add(s2)

则必须重写hashcode()  equals()方法，也可自动生成。

如下public int hashCode()
        {
                final int prime = 31;
                int result = 1;
                result = prime * result + ((name == null) ? 0 : name.hashCode());
                return result;
        }

        public boolean equals(Object obj)
        {
                if (this == obj)
                        return true;
                if (obj == null)
                        return false;
                if (getClass() != obj.getClass())
                        return false;
                Student other = (Student) obj;
                if (name == null)
                {
                        if (other.name != null)
                                return false;
                }
                else if (!name.equals(other.name))
                        return false;
                return true;
        }

最简单的就是
一个或多个成员变量的值相等（比如id,name）等，就认为这两个对象相等。

在这种情况下，就好办了
Set set = new HashSet();
set.addAll(list);
到这一步，已经利用set的特性去重了。

接下来再把去重后的集合放到一个新的list去即可
List newlist = new ArrayList();
newlist.addAll(set);

去重本身很简单。
复杂在对‘对象相等’概念的理解。

默认情况下，两个对象在继承了Object的方法后，
只有当堆内存地址相等的情况下，才相等。
所以，必须要自己重写equals和hashCode

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.TreeSet;

public class TestListRepeat {
        public static void main(String[] args) {
                List list = new ArrayList();

                list.add("zhangsan");
                list.add("lisi");
                list.add("zhangsan");
                list.add("wangwu");
                list.add("zhangsan");
                Iterator iterator = list.iterator();
                TreeSet set = new TreeSet();
                while (iterator.hasNext()) {
                        set.add(iterator.next());

                }
                iterator = set.iterator();
                while (iterator.hasNext()) {
                        System.out.println(iterator.next());

                }
                //你看这样可以吗？利用set不允许出现重复元素的特性来去除重复的元素

        }
}

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

复制代码

楼主，我简单说一下，你可以看看集合的特点：
list集合中的元素师有序的，可以重复的，set集合中的元素师无序的，是不可以重复的！
你想去掉list集合中重复的元素貌似很难，那就只有楼上几位说的先存进hashset集合中，依靠hashset集合的特点，自动去掉重复元素，在遍历出来存进list集合

程振 发表于 2012-9-22 22:50

谢谢，利用HashSet集合的特性确实去掉了重复的元素