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

/*
将自定义对象作为元素存到ArrayList集合中，并去除重复元素、
比如：存人对象。同姓名同年龄，视为同一个人，为重复元素。

思路：
1、找人描述，将数据封装进人对象。
2、定义容器，将人存入。
3、取出。
*/

1. 
   
2. //定义人类
   
3. class Person
   
4. {
   
5.         private String name;
   
6.         private int age;
   
7.         Person(String name, int age)
   
8.         {
   
9.                 this.name = name;
   
10.                 this.age = age;
    
11.         }
    
12. 
    
13.         //重写equals方法。判断容器中的元素是否相同
    
14.         public boolean equals(Object obj)
    
15.         {
    
16.                 if(!(obj instanceof Person)) //判断一下Person是否属于Obj类。不是的话就返回false
    
17.                         return false;
    
18.                 Person p = (Person)obj; //因为传入的数据在传入时类型自动提升了。所以在次数需要把类型向下强制转型
    
19.                 System.out.println(p.getName());
    
20.                 return this.name.equals(p.name) && this.age == p.age;
    
21.         }
    
22.         
    
23.         //设置名字
    
24.         public void setName(String name)
    
25.         {
    
26.                 this.name = name;
    
27.         }
    
28.         
    
29.         //取出名字
    
30.         public String getName()
    
31.         {
    
32.                 return name;
    
33.         }
    
34.         
    
35.         //设置年龄
    
36.         public void setAge(int age)
    
37.         {
    
38.                 this.age = age;
    
39.         }
    
40. 
    
41.         //取出年龄
    
42.         public int getAge()
    
43.         {
    
44.                 return age;
    
45.         }
    
46. 
    
47. }
    
48. 
    
49. class ArrayListTest1
    
50. {
    
51.         public static void main(String[] args)
    
52.         {
    
53.                 //创建一个容器
    
54.                 ArrayList al = new ArrayList();
    
55.                 al.add(new Person("张三", 31));
    
56.                 al.add(new Person("张四", 32));
    
57.                 al.add(new Person("张三", 31));
    
58.                 al.add(new Person("张四", 32));
    
59.                 al.add(new Person("张五", 33));
    
60.                 al.add(new Person("张六", 34));
    
61. 
    
62.                 //取出名字   创建迭代器
    
63.                 Iterator it = al.iterator();
    
64.                 for( ;it.hasNext(); ) //判断容器中是否还有元素存在。有就往下执行
    
65.                 {
    
66.                         Person p = (Person)it.next(); //因为it.next()返回的是一个Object类型的元素。所以需要向下转型
    
67.                         System.out.println(p.getName() + ":::::" + p.getAge());
    
68.                 }
    
69.         }
    
70. }

复制代码

运行结果是：
而毕老师的视频上却可以去除重复的。求大神指教一下。我的到底错在哪里了吗？
我已经找了n遍。却始终无法找到错在何处

补充一句，好像contains()会去调用equals()函数，就是这样了，求给分

楼主你好，你只需要在每次插入操作前执行contain()函数即可解决问题，因为你虽然重写了equals()函数，但却没有去调用它，一下是我的建议代码:

1. import java.util.ArrayList;
   
2. import java.util.Iterator;
   
3. 
   
4. /*
   
5. 将自定义对象作为元素存到ArrayList集合中，并去除重复元素、
   
6. 比如：存人对象。同姓名同年龄，视为同一个人，为重复元素。
   
7. 
   
8. 思路：
   
9. 1、找人描述，将数据封装进人对象。
   
10. 2、定义容器，将人存入。
    
11. 3、取出。
    
12. */
    
13. 
    
14. 
    
15. //定义人类
    
16. 
    
17. class Person
    
18. 
    
19. {
    
20. 
    
21.         private String name;
    
22. 
    
23.         private int age;
    
24. 
    
25.         Person(String name, int age)
    
26. 
    
27.         {
    
28. 
    
29.                 this.name = name;
    
30. 
    
31.                 this.age = age;
    
32. 
    
33.         }
    
34. 
    
35. 
    
36. 
    
37.         //重写equals方法。判断容器中的元素是否相同
    
38. 
    
39.         public boolean equals(Object obj)
    
40. 
    
41.         {
    
42. 
    
43.                 if(!(obj instanceof Person)) //判断一下Person是否属于Obj类。不是的话就返回false
    
44. 
    
45.                         return false;
    
46. 
    
47.                 Person p = (Person)obj; //因为传入的数据在传入时类型自动提升了。所以在次数需要把类型向下强制转型
    
48. 
    
49.                 System.out.println(p.getName());
    
50. 
    
51.                 return this.name.equals(p.name) && this.age == p.age;
    
52. 
    
53.         }
    
54. 
    
55.         
    
56. 
    
57.         //设置名字
    
58. 
    
59.         public void setName(String name)
    
60. 
    
61.         {
    
62. 
    
63.                 this.name = name;
    
64. 
    
65.         }
    
66. 
    
67.         
    
68. 
    
69.         //取出名字
    
70. 
    
71.         public String getName()
    
72. 
    
73.         {
    
74. 
    
75.                 return name;
    
76. 
    
77.         }
    
78. 
    
79.         
    
80. 
    
81.         //设置年龄
    
82. 
    
83.         public void setAge(int age)
    
84. 
    
85.         {
    
86. 
    
87.                 this.age = age;
    
88. 
    
89.         }
    
90. 
    
91. 
    
92. 
    
93.         //取出年龄
    
94. 
    
95.         public int getAge()
    
96. 
    
97.         {
    
98. 
    
99.                 return age;
    
100. 
     
101.         }
     
102. 
     
103. 
     
104. 
     
105. }
     
106. 
     
107. 
     
108. 
     
109. class ArrayListTest1
     
110. 
     
111. {
     
112. 
     
113.         public static void main(String[] args)
     
114. 
     
115.         {
     
116. 
     
117.                 //创建一个容器
     
118. 
     
119.                 ArrayList al = new ArrayList();
     
120.                p1=new Person("张三"，31)；
     
121.                p2=new Person("张四"，38)；
     
122.                p3=new Person("张五"，31)；
     
123.                p4=new Person("张六"，36)；      
     
124.                p5=new Person("张七"，39)；
     
125.                p6=new Person("张四"，38)；
     
126.                p7=new Person("张三"，31)；
     
127.                for(int i=0;i<7;i++){
     
128.                   if(!al.contains(p1))
     
129.                     al.add(p1);
     
130.                  if(!al.contains(p2))
     
131.                     al.add(p);
     
132.                  if(!al.contains(p3))
     
133.                     al.add(p3);
     
134.                   if(!al.contains(p4))
     
135.                     al.add(p4);
     
136.                    if(!al.contains(p5))
     
137.                     al.add(p5);
     
138.                       if(!al.contains(p6))
     
139.                     al.add(p6);
     
140.                     if(!al.contains(p7))
     
141.                     al.add(p7);
     
142.                   
     
143.                      
     
144.                   
     
145.                      
     
146. 
     
147. 
     
148.              }
     
149. 
     
150.                 //取出名字   创建迭代器
     
151. 
     
152.                 Iterator it = al.iterator();
     
153. 
     
154.                 for( ;it.hasNext(); ) //判断容器中是否还有元素存在。有就往下执行
     
155. 
     
156.                 {
     
157. 
     
158.                         Person p = (Person)it.next(); //因为it.next()返回的是一个Object类型的元素。所以需要向下转型
     
159. 
     
160. 
     
161.                         System.out.println(p.getName() + ":::::" + p.getAge());
     
162. 
     
163.                 }
     
164. 
     
165.         }
     
166. 
     
167. }

复制代码

楼主你好，

恩恩是的

追逐 发表于 2014-3-22 15:30
这个是输出结果，请大神在帮忙改改 了

你运行的是我的程序么？

明白了了。运行通过 了。谢谢各位的帮助

list中的元素可以重复，但是要保证list元素的唯一，就重写equals方法，但是你没有自己定义去除重复元素的方法，也就是说即使你覆盖了equals方法，但是他们还都存在list里面，jvm已经知道他们是重复的但是没有删除，你没有个jvm删除的方法。
很明显缺少代码，最少应该定义两个list？没写全吧。7楼写的对，你看看吧。

我感觉优势很大 发表于 2014-3-22 14:57
这个list集合是自己写方法删除重复元素，里面的那个 singleElement（）方法，就是去除重复元素的，[/backco ...

这个是输出结果，请大神在帮忙改改 了

1. import java.util.ArrayList;
   
2. import java.util.Iterator;
   
3. 
   
4. //List集合判断元素是否相同，依据是元素的equals方法
   
5. public class ArrayListDemo2 {
   
6. 
   
7.         public static void main(String[] args) {
   
8.                 // TODO Auto-generated method stub
   
9.                 ArrayList<Person> al=new ArrayList<Person>();
   
10.                
    
11.                 al.add(new Person("lisi01",31));
    
12.                 al.add(new Person("lisi01",31));
    
13.                 al.add(new Person("lisi02",32));
    
14.                 al.add(new Person("lisi03",33));
    
15.                 al.add(new Person("lisi03",33));
    
16.                
    
17.                 Iterator<Person> it=al.iterator();
    
18.                 while(it.hasNext())
    
19.                 {
    
20.                         Person p=it.next();
    
21.                         System.out.println(p.getName()+"..."+p.getAge());
    
22.                 }
    
23.                
    
24.                 al=singleElement(al);
    
25.                
    
26.                 System.out.println("-----------------------");
    
27.                
    
28.                 Iterator<Person> it1=al.iterator();
    
29.                 while(it1.hasNext())
    
30.                 {
    
31.                         Person p=it1.next();
    
32.                         System.out.println(p.getName()+"..."+p.getAge());
    
33.                 }
    
34.         }
    
35.        
    
36.        
    
37.         public static ArrayList singleElement(ArrayList al){
    
38.                 ArrayList newAl=new ArrayList();
    
39.                
    
40.                 Iterator it=al.iterator();
    
41.                 while(it.hasNext())
    
42.                 {
    
43.                         Object obj=it.next();
    
44.                         if(!newAl.contains(obj))//contains方法调用元素的equals方法，看是否是相同元素
    
45.                         {
    
46.                                 newAl.add(obj);
    
47.                         }
    
48.                 }
    
49.                 return newAl;
    
50.                
    
51.         }
    
52. 
    
53. }
    
54. 
    
55. class Person{
    
56.         private String name;
    
57.         private int age;
    
58.         public Person(String name, int age) {
    
59.                 this.name = name;
    
60.                 this.age = age;
    
61.         }
    
62.         public String getName() {
    
63.                 return name;
    
64.         }
    
65.         public void setName(String name) {
    
66.                 this.name = name;
    
67.         }
    
68.         public int getAge() {
    
69.                 return age;
    
70.         }
    
71.         public void setAge(int age) {
    
72.                 this.age = age;
    
73.         }
    
74.         @Override
    
75.         public boolean equals(Object obj) {
    
76.                 // TODO Auto-generated method stub
    
77.                 if(!(obj instanceof Person))
    
78.                         return false;
    
79.                 Person p=(Person)obj;
    
80.                 return this.name.equals(p.getName())&&this.age==p.getAge();
    
81.         }
    
82. }
    

复制代码

这个list集合是自己写方法删除重复元素，里面的那个 singleElement（）方法，就是去除重复元素的，

ArrayList需要你自己调用remove方法去删除重复元素，Set集合因为它本身不能存储重复的元素，所以只需要复写hashCode和equals方法或者CompareTo方法就行

现在就是删除重复的方法不能用了 的。

ArrayList本来就是可以存储重复的元素的吧，你要弄一个方法去删除重复的

但是还没学习到Set，而且现在遇到这种问题也不能不修改啊。忘各位路过的大神指点一下