1. class Person
   
2. {
   
3.         private String name;
   
4.         private int age;
   
5.         Person(String name,int age)
   
6.         {
   
7.                 this.name=name;
   
8.                 this.age=age;
   
9.         }
   
10. 
    
11.         public boolean equals(Object obj)
    
12.         {
    
13.                 System.out.println("7");
    
14.                 if(!(obj instanceof Person))
    
15.                         return false;
    
16. 
    
17.                 Person p=(Person)obj;
    
18.                 System.out.println(this.name+"..."+p.name);
    
19.                 return this.name.equals(p.name)&&this.age==p.age;
    
20.         }
    
21. 
    
22. 
    
23. 
    
24.         public String getName()
    
25.         {
    
26.                 return name;
    
27.         }
    
28. 
    
29.         public int getAge()
    
30.         {
    
31.                 return age;
    
32.         }
    
33. }
    
34. 
    
35. class ArrayListTest2
    
36. {
    
37.         public static void main(String[] args)
    
38.         {
    
39.                 ArrayList al=new ArrayList();
    
40.                 al.add(new Person("lisi01",20));
    
41.                 al.add(new Person("lisi02",28));
    
42.                 al.add(new Person("lisi03",27));
    
43.                 al.add(new Person("lisi04",26));
    
44.                 al.add(new Person("lisi05",25));
    
45.                 al.add(new Person("lisi06",23));
    
46.                 al.add(new Person("lisi07",21));
    
47.                 al.add(new Person("lisi03",27));
    
48.                
    
49.                 sop("1");
    
50.                 al=singleElement(al);
    
51.                 sop("2");
    
52.                 Iterator it=al.iterator();
    
53.                 sop("3");
    
54.                 while(it.hasNext())
    
55.                 {
    
56.                         sop("4");
    
57.                         Person p=(Person)it.next();
    
58.                         sop("5");
    
59.                         sop(p.getName()+"::"+p.getAge());
    
60.                         sop("6");
    
61.                 }
    
62. 
    
63.         }
    
64. 
    
65.         public static ArrayList singleElement(ArrayList al)
    
66.         {
    
67.                 //定义一个临时容器
    
68.                 ArrayList newaArrayList=new ArrayList();
    
69.                 Iterator iterator=al.iterator();
    
70.                 while (iterator.hasNext()) {
    
71.                         Object obj=iterator.next();
    
72.                         if (!newaArrayList.contains(obj)) {
    
73.                                 newaArrayList.add(obj);
    
74.                         }
    
75.                         
    
76.                 }
    
77.                 return newaArrayList;
    
78.         }
    
79.         public static void sop(Object obj)
    
80.         {
    
81.                 System.out.println(obj);
    
82.         }
    
83. }

复制代码

这是视频中的一个例子，重写了equals方法，视频里讲是因为contanse（Object obj） 中有 equals方法
是说这里面的equals只能比较地址么，而不是equals(Object obj)

equals(Object obj)这个方法在什么时候用

从Object中继承下载的equals是比较内存地址的。在使用List集合，Set集合时，Map时，可根据自己的需要重写此方法，当然，使用了哈希表的集合也要覆写hashcode方法

"=="和equals方法究竟有什么区别？
==操作符专门用来比较变量的值是否相等。比较好理解的一点是：
对象变量其实是一个引用，它们的值是指向对象所在的内存地址，而不是对象本身 。
a和b都使用了new操作符，意味着将在内存中产生两个内容为"foo"的字符串，
既然是"两个",它们自然位于不同的内存地址。a和b的值其实是两个不同的内存地址的值，
所以使用"=="操作符，结果会是false.诚然，a和b所指的对象，它们的内容都是"foo",
应该是"相等",但是==操作符并不涉及到对象内容的比较。对象内容的比较，正是equals方
法做的事。看一下Object对象的equals方法是如何实现的：
　　boolean equals(Object o){
　　return this==o;}
　　Object对象默认使用了==操作符。所以如果你自创的类没有覆盖equals方法，那你的类
使用equals和使用==会得到同样的结果。同样也可以看出，Object的equals方法没有达到
equals方法应该达到的目标：比较两个对象内容是否相等。因为答案应该由类的创建者决定，
所以Object把这个任务留给了类的创建者。所以当你是用equals方法判断对象的内容是否相等,
请不要想当然。因为可能你认为相等，而这个类的作者不这样认为，而类的equals方法的实现是
由他掌握的。如果你需要使用equals方法，或者使用任何基于散列码的集合(HashSet,HashMap,HashTable)，
请查看一下java doc以确认这个类的equals逻辑是如何实现的。

equals一般都是被重写的

因为默认在ArrayList中可以存放相同的元素，因为有索引。如果要元素唯一，我们可以复写equals方法，指定哪些条件相同即为相同元素

  1,  此案例中的equals方法是重写了Object类的equals()，判断同名同年龄的人是同一个人。
2,   没有重写Object中的equals()，那默认比较的是地址值，这个时候它和 == 相等。对我们来说一般没有意义。所以，一般我们会根据需求重写equals()。
      所以什么时候用得看需求

你自己都不是说了Object中的equals是比较两个对象的地址吗。
如果你的需求不是要比较两个对象的地址是否一样来判断两个是否相等，就要自定义equals方法，覆盖掉Object中的equals方法。
一般我们的需求是要比较对象中的各个属性是否相等，来判断两个对象是否相等。
你上面的代码中的Person类就是依据name 和 age属性来比较两个对象是否相等的。