//将自定义对象作为元素存到ArrayList集合中，并去除重复元素。
import java.util.*;
class Person
{
        private String name;
        private int age;
        Person(String name,int age)
                {
                this.name=name;
                this.age=age;
                }
        public boolean equals(Object obj)
                {
                if(!(obj instanceof Person))
                        return false;
                Person p=(Person)obj;
                return this.name.equals(p.name)&&this.age==p.age;
                }
        public void setName(String name)
                {
                this.name=name;
                }
        public String getName()
                {
                return name;
                }
        public void setAge(int age)
                {
                this.age=age;
                }
        public int getAge()
                {
                return age;
                }
}
class ArrayListTest2
{
        public static void sop(Object obj)
                {
                System.out.println(obj);
                }
        public static void main(String[] name)
                {
                ArrayList al=new ArrayList();
                al.add(new Person("lishi",30));
                al.add(new Person("lishi",32));
                al.add(new Person("lishi",32));
                al.add(new Person("lishi",34));
                al.add(new Person("lishi",34));
                al=singleElements(al);
                Iterator it=al.iterator();
                while(it.hasNext())
                        {
                        Person p=(Person)it.next();
                        System.out.println(p.getName()+":"+p.getAge());
                        }
                }
                public static ArrayList singleElements(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;
                        }
}


这是毕老师视频中的例子：
我不明白的是难道判断List集合元素的是否相同，是不是必须用红色部分的代码？
判断List元素是否相同，用equals方法不就行了吗？
为什么还得定义一个临时的容器呢？？？有没有更好的方法呢？{:soso_e100:}

{
                         ArrayList newAl=new ArrayList();//定义一个临时容器
                         Iterator it=al.iterator();
                         while(it.hasNext())
                                 {
                                 Object obj=it.next();
                                 if(!newAl.contains(obj))
                                         newAl.add(obj);
                                 }
                                 return newAl;
这段代码的意思是先定义一个容器，然后利用迭代，将元集合的元素一个个的存入到新的临时容器中，在加入的过程中，有一个判断，那就是if(!newAl.contains(obj))，即如果要存入的元素已经在了新的容器中，那么就不存了，通过这个方法，可以把重复的元素给抛出去。
其实重点就在contains方法中的底层运用到了equals方法，这也是person类中，复写equals方法的原因。

至于简单的方法，不知道，其实用set可以实现去掉重复的元素。
也不大简单，也不知道有没有更简单的。

1. import java.util.ArrayList;
   
2. import java.util.Collection;
   
3. import java.util.Comparator;
   
4. import java.util.HashSet;
   
5. import java.util.Iterator;
   
6. import java.util.TreeSet;
   
7. 
   
8. public class Setaaaa {
   
9.         public static void main(String[] args)
   
10.         {
    
11.                 ArrayList al=new ArrayList();
    
12.                 al.add(new Person("zhangsan",21));
    
13.                 al.add(new Person("zhangsan",22));
    
14.                 al.add(new Person("zhangsan",21));
    
15. 
    
16.                 TreeSet ts=new TreeSet(new MyComaparet());
    
17.                 ts.addAll(al);
    
18.                 Iterator it=ts.iterator();
    
19.                 while(it.hasNext()){
    
20.                         Person p=(Person)it.next();
    
21.                         sop(p.getName()+"-------"+p.getAge());
    
22.                 }
    
23.         }
    
24.                 public static void sop(Object obj){
    
25.                                 System.out.println(obj);
    
26.                         }
    
27.        
    
28. 
    
29. }
    
30. class MyComaparet implements Comparator{//定义一个比较器
    
31.         public int compare(Object obj1,Object obj2){
    
32.                 Person s1=(Person)obj1;
    
33.                 Person s2=(Person)obj2;
    
34.                 if(s1.getAge()==s2.getAge()&&s1.getName().equals(s2.getName()))
    
35.                         return 0;
    
36.                 return 1;
    
37.         }
    
38. }
    
39. class Person
    
40.                 {
    
41.                         private String name;
    
42.                         private int age;
    
43.                         Person(String n,int a){
    
44.                                 this.name=n;
    
45.                                 this.age=a;       
    
46.                         }
    
47.                         public String getName(){
    
48.                                 return name;
    
49.                         }
    
50.                         public int getAge(){
    
51.                                 return age;
    
52.                         }
    
53. 
    
54.                 }

复制代码

{:soso_e103:}

毕老师没有说吗。list集合中判断对象元素是否相同，其实用的就是equals方法，判断容器中是否包含某种元素，用的就是contains()方法，contains()方法的底层原理用的就是equals方法，你可以查API，里面讲到当且仅当此collection至少包含一个满足(o==null ? e ==null : o.equals(e))的元素e时，返回true。
如果你想用你自己的比较方法，那就覆写父类object的equals方法。毕老师的这段代码中就有。

public static ArrayList singleElements(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;
                         }
这部分代码定义的是一个迭代器，用来对元素进行遍历。