1. package day14.collectionDemo;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.Iterator;
   
5. class Person{
   
6.         private String name;
   
7.         private int age;
   
8.         Person(String name,int age){
   
9.                 this.name = name;
   
10.                 this.age = age;
    
11.         }
    
12.         public void setAge(int age){
    
13.                 this.age = age;
    
14.         }
    
15.         public void setName(String name){
    
16.                 this.name =name;
    
17.         }
    
18.        
    
19.         public String getName(){
    
20.                 return name;
    
21.         }
    
22.         public int getAge(){
    
23.                 return age;
    
24.         }
    
25. //        为什么要重写equals 方法呢？
    
26.         public boolean equals(Object obj){
    
27.                 if(!(obj instanceof Person)){
    
28.                         return false;
    
29.                 }
    
30.                 Person p = (Person)obj;
    
31.                 return this.name.equals(p.name) && this.age == p.age;
    
32.         }
    
33.        
    
34. }
    
35. public class ArrayListText2 {
    
36.         public static void main(String []args){
    
37.                 ArrayList al = new ArrayList();
    
38.                 al.add(new Person("liwu1",32));
    
39.                 al.add(new Person("liwu2",32));
    
40.                 al.add(new Person("liwu3",32));
    
41.                 al.add(new Person("liwu4",32));
    
42.                 al.add(new Person("liwu1",32));
    
43. //                掉用方法。去掉重复
    
44.                 al =singleElements(al);
    
45. //                生成一个迭代器。
    
46.                 Iterator it = al.iterator();
    
47.                 while(it.hasNext()){
    
48.                         Person p = (Person)it.next();
    
49.                         System.out.println(p.getName()+"..."+p.getAge());
    
50.                 }
    
51.         }
    
52.        
    
53.         public static ArrayList singleElements(ArrayList al2){
    
54. //                定义一个临时容器。
    
55.                 ArrayList newAl = new ArrayList();
    
56.                
    
57.                 Iterator it = al2.iterator();
    
58.                
    
59.                  while(it.hasNext()){
    
60.                          
    
61.                          Object obj = it.next();
    
62. //         这contains怎么比较这个集合中是否包含这个对象？
    
63.                          if(!newAl.contains(obj)){
    
64.                                  newAl.add(obj);
    
65.                          }
    
66.                  }return newAl;
    
67.         }
    
68. }

复制代码

如代码所示：这个一个集合中除去重复的对象。
问题1：我的Person类中为什么要重写 equals()方法。
            为什么重写。确去不掉重复呢？关键是，我又没有在什么地方调用这个 equals()方法。
问题2：contains 里面判断集合是否包含 对象。是怎么判断呢？

shisishishisi 发表于 2014-6-4 03:34
其实你的2个问题是一个问题！contains判断集合中是否包含某个元素即调用了equals方法
而对于引用类型若不重 ...

对。谢谢了哦。

提菩--空 发表于 2014-6-4 10:17
ArrarList是可存重复的数据，另外person元素本身不具有比较性，要去掉重复的元素，得让元素具有比较性，二 ...

compare 这个方法我在研究研究，现在不是很清楚，谢谢了   

侯金龙 发表于 2014-6-4 07:53
重写equals是要有自己的比较方法，以便操作对象，contains的操作应该是，先获取每个元素然后比较 ...

嗯。主要当时不是很理解 contains 是怎么进行比较。不过现在想想，contains 会自动调用equals的方法进行比较的。

茂子 发表于 2014-6-4 08:52
这段代码相当于是去掉集合中的重复元素，将不重复的元素放到一个新集合中。
1、虽然equals方法没有被调用， ...

嗯。确实，在用contains进行比较的时候，自动调用的equals。

说的很详细...

ArrarList是可存重复的数据，另外person元素本身不具有比较性，要去掉重复的元素，得让元素具有比较性，二种方式，1，元素实现comparable接口，覆盖compareTo方法。2、实现comparator接口，覆盖compare方法

这段代码相当于是去掉集合中的重复元素，将不重复的元素放到一个新集合中。
1、虽然equals方法没有被调用，但是在集合元素的判断中会默认的调用该函数，contains方法应该就是调用了该方法比较（个人理解）；
2、在没有重写equals方法时，默认调用的equals方法只是对元素的地址值进行比较。然而该段代码，集合每次添加一个对象元素（new Person（"xxx",int）），在堆内存中都会开辟一个新的地址值，所以不复写equals方法就默认的比较这些地址值，而每次开辟的新空间是不可能存在重复的；
3、重写equals的主要目的在于建立自定义的比较方式，以此剔除重复元素。

重写equals是要有自己的比较方法，以便操作对象，contains的操作应该是，先获取每个元素然后比较

newAl.contains(obj)，系统会对Arraylist中的每个元素e调用obj.equals(e)，这个时候已经调用了equals()方法，而且在java中规定要重写equals()方法  要遵守这个规定

其实你的2个问题是一个问题！contains判断集合中是否包含某个元素即调用了equals方法
而对于引用类型若不重写equals则使用的是Object的equals方法，比较的是对象在内存中的地址
这样就达不到你要判断一个集合中是否含有某个元素的目的！所以要重写equals方法！