1. package com.leo.blog;
   
2. import java.util.*;
   
3. class Human
   
4. {
   
5.         private String name;
   
6.         private int age;
   
7.         Human(String name,int age)
   
8.         {
   
9.                 this.age = age;
   
10.                 this.name  = name;
    
11.         }
    
12.         public boolean equals(Object obj)
    
13.         {
    
14.                 if(obj instanceof Human)
    
15.                                 return false;
    
16.                 Human h = (Human) obj;
    
17.                 return this.name.equals(h.name)&&this.age==h.age;
    
18.         }
    
19.         public String getName() {
    
20.                 return name;
    
21.         }
    
22.         public void setName(String name) {
    
23.                 this.name = name;
    
24.         }
    
25.         public int getAge() {
    
26.                 return age;
    
27.         }
    
28.         public void setAge(int age) {
    
29.                 this.age = age;
    
30.         }
    
31. }
    
32. class ArrayListTest {
    
33.        
    
34.         public static void main(String[] args) {
    
35.                
    
36.                 ArrayList al = new ArrayList();
    
37.                 al.add(new Human("LEO",25));
    
38.                 al.add(new Human("LAY",24));
    
39.                 al.add(new Human("KOBE",36));
    
40.                 al.add(new Human("PAUL",35));
    
41.                 System.out.println(al);
    
42.                 System.out.println(singleElement(al));       
    
43.                
    
44.         }
    
45.         public static ArrayList singleElement(ArrayList al)
    
46.         {
    
47.                 //定义一个临时容器
    
48.                 ArrayList newAl = new ArrayList();
    
49.                 Iterator it  = al.iterator();
    
50.                 while(it.hasNext())
    
51.                 {
    
52.                         Object obj = it.next();
    
53.                         if(!newAl.contains(obj))//这里调用了一下contains就调用了equals方法这里有点不明白
    
54.                         {
    
55.                                 newAl.add(obj);
    
56.                         }
    
57.                 }
    
58.                 return newAl;
    
59.         }
    
60. }
    

复制代码

if(!newAl.contains(obj))//这里调用了一下contains就调用了equals方法这里有点不明白毕老师在讲这里的时候说是调用了contains方法就调用了equals，但是查阅了api也没发现有哪里有调用，麻烦讲解一下~谢过~~
                       

下面是ArrayList的API注释：

contains
public boolean contains(Object o)如果此列表中包含指定的元素，则返回 true。更确切地讲，当且仅当此列表包含至少一个满足 (o==null ? e==null : o.equals(e)) 的元素 e 时，则返回 true。

指定者：
接口 Collection<E> 中的 contains
指定者：
接口 List<E> 中的 contains
覆盖：
类 AbstractCollection<E> 中的 contains
参数：
o - 测试此列表中是否存在的元素
返回：
如果此列表包含特定的元素，则返回 true

分析   (o==null ? e==null : o.equals(e))
o是ArrayList集合中的元素，当o存在时（不为null），利用o这个元素自身的equals方法遍历判断ArrayList中是否有该元素e。

看源代码：contains调用的是indexOf(); indesOf()调用了equals。  ArrayList查找d遍历查找
public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }

public int indexOf(Object o) {
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

查看ArrayList的API文档，找到其contain方法，你就能知道为什么了。API文档解释如下：
contains
public boolean contains(Object o)如果此列表中包含指定的元素，则返回 true。更确切地讲，当且仅当此列表包含至少一个满足 (o==null ? e==null : o.equals(e)) 的元素 e 时，则返回 true。

指定者：
接口 Collection<E> 中的 contains
指定者：
接口 List<E> 中的 contains
覆盖：
类 AbstractCollection<E> 中的 contains
参数：
o - 测试此列表中是否存在的元素
返回：
如果此列表包含特定的元素，则返回 true

可以看出contain方法运行时是拿该元素去和ArrayList中的每一个元素进行比较，而比较的时候是用的是equals,
(o==null ? e==null : o.equals(e)),contain的底层调用实际用的是equals方法

list中判断元素是是否相同的依据是equals方法

调用contains会和obj比较，并且符合(e1==null ? e2==null : e1.equals(e2))，的条件，如果obj不是null，则调用equals判断返回true还是false,所以上面复写类的equals方法来加以判断。

毕老师说的意思是  调用contains方法查询集合中有没有你要找的这个元素，既然要查询集合中有没有这个元素，那就一定要把这个集合里的所有元素分别于该元素进行比较，比较用的就是equals方法，意思就是说，contains这个方法内部用到了equals方法

你明白ArrayList集合的原理就明白了
Arraylist集合存入的时候是按顺序存入的，元素之间没有按规律排序。
你调用contains方法的时候集合就会把你传入的元素和集合中的每个元素一一比较，相当于调用了元素的equals方法。当equals方法返回true的时候集合里面有相同的元素。
相当于遍历集合元素，然后调用equals比较元素值。