package collection;

import java.util.ArrayList;
import java.util.Iterator;


public class ArrayListDemo2
{
        public static void sop(Object obj)
        {
                System.out.println(obj);
        }
        public static void main(String[] args)
        {
                ArrayList al=new ArrayList();
                al.add(new Person("lisi01",30));
                al.add(new Person("lisi02",32));
                al.add(new Person("lisi02",32));
                al.add(new Person("lisi03",33));
                al.add(new Person("lisi04",35));
                al.add(new Person("lisi04",35));
               
               
                al=singleElement(al);
                Iterator it=al.iterator();
               
                while(it.hasNext())
                {
                       
                        Person p=(Person)it.next();
                        sop(p.getName()+"::"+p.getAge());
                }

        }
        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;
               
        }
}


        class Person {
                private int age;
                private String name;
                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;
                        System.out.println(this.name+"......"+p.name);
                        return this.name.equals(p.name)&&this.age==p.age;
                }
                public String getName()
                {
                        return name;
                }
                public int getAge()
                {
                        return age;
                }

        }
是怎样实现去除重复元素的，越详细越好

朋友我帮你注释了一下，不明白可以PM我
import java.util.ArrayList;
import java.util.Iterator;
public class ArrayListDemo2 {
public static void sop(Object obj) {
  System.out.println(obj);
}
public static void main(String[] args) {
  ArrayList<Object> al = new ArrayList<Object>();
  al.add(new Person("lisi01", 30));
  al.add(new Person("lisi02", 32));
  al.add(new Person("lisi02", 32));
  al.add(new Person("lisi03", 33));
  al.add(new Person("lisi04", 35));
  al.add(new Person("lisi04", 35));
  al = singleElement(al);// 使用相同类型的集合变量来接收新的集合
  Iterator<Object> it = al.iterator();// 仍旧是对于新鲜集合的迭代
  while (it.hasNext())// 仍旧是对于新集合的迭代
  {
   Person p = (Person) it.next();
   sop(p.getName() + "::" + p.getAge());
  }
}
public static ArrayList<Object> singleElement(ArrayList<Object> al) {
  // 定义一个临时容器
  ArrayList<Object> newAl = new ArrayList<Object>();
  Iterator<Object> it = al.iterator();// 对于传进来的集合建一个迭代器对象
  while (it.hasNext()) {
   Object obj = it.next();// 对于传进来的集合进行对象的迭代
   if (!newAl.contains(obj))// 如果新的集合中不包含这个对象，
    newAl.add(obj);// 则把这个对象加入新的集合中（这样新的集合就不会有重复的对象）
  }
  return newAl;
}
}
class Person {
private int age;
private String name;
Person(String name, int age) {
  this.name = name;
  this.age = age;
}
public boolean equals(Object obj)// 重写equals方法
{
  if (!(obj instanceof Person))
   return false;
  Person p = (Person) obj;
  // System.out.println(this.name+"......"+p.name);
  return this.name.equals(p.name) && this.age == p.age;// name和age都相同才相同
}
public String getName() {
  return name;
}
public int getAge() {
  return age;
}
}

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


这个简单来说既是，利用集合容器的contains方法来看，你看啊，你有个容器是吧，有元素是吧，(这里就算有重复的也没关系)，然后你创建了一个过滤重复元素的方法，里面新建了容器，并带有参数，你把要过滤重复元素的容器传进来，和里面的元素contains下，看下里面那个里面包不包含外面那个传进来的容器里面的元素，这时候里面的容器是空的。
对传进来的容器，进行遍历，如果包含不存入，如果不包含就存入，当遍历完后，剩下的就是 唯一的，最后是返回的是新容器，但是重复的已经过滤掉了。过滤完毕，所以你看到的是过滤掉的。

1. package collection;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.Iterator;
   
5. 
   
6. 
   
7. public class ArrayListDemo2
   
8. {
   
9.         public static void sop(Object obj)
   
10.         {
    
11.                 System.out.println(obj);
    
12.         }
    
13.         public static void main(String[] args)
    
14.         {
    
15.                 ArrayList al=new ArrayList();//创建一个容器  将下列元素放入容器中
    
16.                 al.add(new Person("lisi01",30));
    
17.                 al.add(new Person("lisi02",32));
    
18.                 al.add(new Person("lisi02",32));
    
19.                 al.add(new Person("lisi03",33));
    
20.                 al.add(new Person("lisi04",35));
    
21.                 al.add(new Person("lisi04",35));
    
22.                
    
23.                
    
24.                 al=singleElement(al);//调用singleElement方法  将al中不重复的元素返回
    
25.                 Iterator it=al.iterator();
    
26.                
    
27.                 while(it.hasNext())//使用迭代器
    
28.                 {
    
29.                         
    
30.                         Person p=(Person)it.next();//因为要使用Peson类的特有方法  所以要向下转型
    
31.                         sop(p.getName()+"::"+p.getAge());
    
32.                 }
    
33. 
    
34.         }
    
35.         public static ArrayList singleElement(ArrayList al)
    
36.         {
    
37.                
    
38.                 ArrayList newAl=new ArrayList();//定义一个临时容器，用来存放不包含的元素
    
39.                
    
40.                 Iterator it=al.iterator();
    
41.                
    
42.                 while(it.hasNext())//使用迭代器
    
43.                 {
    
44.                         Object obj=it.next();
    
45.                         
    
46.                         if(!newAl.contains(obj))//contains方法依赖于equals方法 所以先前复写equals方法
    
47.                                                                         //用来比较元素内容是否相同，contains方法用于判断临时容器newAl中是否包含指定的元素obj 如果newAl中包含
    
48.                                                                                                 //obj
    
49.                                 newAl.add(obj);//如果不包含  那么就将obj放入newAl中
    
50.                 }
    
51.                 return newAl;//将容器newAl返回，存放的为al中不重复的元素
    
52.                
    
53.         }
    
54. }
    
55. 
    
56. 
    
57.         class Person {
    
58.                 private int age;
    
59.                 private String name;
    
60.                 Person(String name,int age)
    
61.                 {
    
62.                         this.name=name;
    
63.                         this.age=age;
    
64.                 }
    
65.                 public boolean equals(Object obj)//复写Object类的equals方法
    
66. 为                {
    
67.                         
    
68.                         
    
69.                         if(!(obj instanceof Person))//判断obj是否为Person类的实例
    
70.                                 return false;
    
71.                         Person p=(Person)obj;//由于obj为Person的实例，但它被Object提升所以
    
72.                                                                     //   如果需要使用子类特有的方法 需要进行向下转型
    
73.                         System.out.println(this.name+"......"+p.name);
    
74.                         return this.name.equals(p.name)&&this.age==p.age;//使用Person的特有方法  进行比较
    
75.                 }
    
76.                 public String getName()
    
77.                 {
    
78.                         return name;
    
79.                 }
    
80.                 public int getAge()
    
81.                 {
    
82.                         return age;
    
83.                 }
    
84. 
    
85.         }
    

复制代码