import java.util.*;
class Person
{
        private String name;
        private int    age;
        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;
        }

}
class  Noname9
{
        public static void main(String[] args)
        {
                ArrayList al = new ArrayList();

                al.add(new Person("zhangsan01",31));
                al.add(new Person("zhangsan01",31));
                al.add(new Person("zhangsan03",32));
                al.add(new Person("zhangsan05",34));
                al.add(new Person("zhangsan05",34));

                Iterator it = al.iterator();
        while(it.hasNext())
                {
                        Person p = (Person) it.next();
                        sop("name: "+p.getName()+"--"+"age: "+p.getAge());
                }

        }
        public static void sop(Object obj)
        {
                System.out.println(obj);
        }
}
要实现的功能为：当向ArrayList中添加Person对象的时候，调用Person类中的equals方法，将name和age一样的对象，认为是相同的对象，在ArrayList只存储一个，保证里面没有重复对象，
但是结果却是
全部都添加进出了
这是为什么呢？

ArraryList特点:底层实现数据结构是数组结构，查询效率高，增删效率低，且因为其存在角标，是有序的，所以可以储存相同的对象，其存入的地址（角标）不同。

list集合的特点是有有序的，每次添加等于是从下一新的角标开始，存储不会自动调用equals比较内容的，其存储内容可以指向同一对象，或者具有相同内容的不同对象
比如下面代码

1. ArrayList al = new ArrayList();
   
2. Person per = new Person("zhangsan05",34);
   
3.              al.add(per);
   
4.              al.add(per);
   
5.              al.add(per);
   
6.              al.add(per);
   
7.              al.add(per);

复制代码

添加了5次，都是同一对象，
打印结果是：
name: zhangsan05--age: 34
name: zhangsan05--age: 34
name: zhangsan05--age: 34
name: zhangsan05--age: 34
name: zhangsan05--age: 34

ArrayList里是可以有重复元素的，所以你的equals方法不会调用，如果是其他集合就会调用了，因为其他集合元素必须唯一

这样才是正常的啊，因为List本来就是不会自动调用equals方法的，它都是存于新的脚标下，所以重写是没意义的，估计是和Set弄混了
付Set的添加方法，过去写的博客....

1. import java.util.*;
   
2. 
   
3. public class Test
   
4. {
   
5.     public static void main(String[] args)
   
6.     {
   
7.         HashSet hs = new HashSet();
   
8.         hs.add(new  Smile("呵呵"));
   
9.         hs.add(new  Smile("呵呵"));
   
10.         System.out.println(hs);
    
11.         System.out.println("------分割线------");
    
12.       
    
13.         Smile s=new Smile("嘿嘿");
    
14.         hs.add(s);
    
15.         hs.add(s);
    
16.         System.out.println(hs);
    
17.         System.out.println("======分割线======");//Smile继承object的hashCode和equals方法
    
18.       
    
19.         String s1 = new String("哈哈");
    
20.         String s2 = new String("哈");
    
21.         hs.add(s1);
    
22.         hs.add(s2);
    
23.         System.out.println(hs);//String类重写过hashCode与equals所以就不同于Smile，不能添加相同的
    
24.         
    
25.     }
    
26.    
    
27. }
    
28. 
    
29. class Smile
    
30. {
    
31.     String name;
    
32.     Smile(String name)
    
33.     {
    
34.         this.name=name;
    
35.     }
    
36.     public String toString() {
    
37.     return name;
    
38.     }
    
39. }
    
40. 
    
41. 
    
42. 输出结果是：[呵呵, 呵呵]
    
43. ------分割线------
    
44. [呵呵, 呵呵, 嘿嘿]
    
45. ======分割线======
    
46. [哈哈, 呵呵, 呵呵, 嘿嘿]

复制代码

|--List : 元素是有序的，元素可以重复。因为该集合体系有索引
                |--ArrayList: 底层的数据结构使用的是数组结构。 线程不同步
                |--LinkedList: 底层的数据结构使用的是链表结构
                |--Vector: 底层是数组数据结构。 线程同步。被ArrayList替代了
        |--Set  ：元素是无序，元素不可以重复
                |--HashSet:数据结构是哈希表，线程时非同步的
                                        保证元素唯一性的原理：判断hashCode值是否相同，如果相同继续判断equals方法，是否为true
                |--TreeSet：可以对Set集合中的元素进行排序，底层数据结构是二叉树
                                        保证元素唯一性的依据：compareTo方法返回值是否为0
                                       
                                        TreeSet集合的第一种排序方式：让元素自身具备比较性
                                                元素需要实现Comparable接口，覆盖compareTo方法，这种方式称为元素的自然顺序
                                        TreeSet集合的第二种排序方式：当元素自身不具备比较性，或者具备的比较性不是所需要的
                                                这时需要让容器自身具备比较性
                                                定义比较器，将比较器对象作为参数传递给TreeSet集合的构造函数


ArrayList集合中可以存储相同的元素，在存储中不会判断equals方法，按下标的顺序依次存入，如果要存入不同的元素，需要使用Set集合，覆盖hashCode方法，equals方法，并实现Comparable接口覆盖compareTo方法

代码演示：

1. public class Set {
   
2.         public static void main(String[] args){
   
3.                 TreeSet<Person> ts = new TreeSet<Person>();
   
4.                 ts.add(new Person("lisi01",11));
   
5.                 ts.add(new Person("lisi02",12));
   
6.                 ts.add(new Person("lisi01",13));
   
7.                 ts.add(new Person("lisi04",11));
   
8.                
   
9.                 Iterator<Person> it = ts.iterator();
   
10.                 while(it.hasNext()){
    
11.                         Person p = it.next();
    
12.                         System.out.println(p);
    
13.                 }
    
14.         }
    
15. }
    
16. 
    
17. class Person implements Comparable<Person>{
    
18.         private int age;
    
19.         private String name;
    
20.         Person(String name,int age){
    
21.                 this.name = name;
    
22.                 this.age = age;
    
23.         }
    
24.        
    
25.         @Override
    
26.         public int compareTo(Person p){
    
27.                 int num = new Integer(this.age).compareTo(new Integer(p.age));
    
28.                 if(num==0)
    
29.                         return this.name.compareTo(p.name);
    
30.                 return num;
    
31.         }
    
32.        
    
33.         @Override
    
34.         public int hashCode(){
    
35.                 return name.hashCode()+age*39;
    
36.         }
    
37.        
    
38.         @Override
    
39.         public boolean equals(Object obj){
    
40.                 if(obj instanceof Person)
    
41.                         throw new RuntimeException("error");
    
42.                 Person p = (Person)obj;
    
43.                 return name.equals(p.name) && age==p.age;
    
44.         }
    
45.        
    
46.         public int getAge(){
    
47.                 return age;
    
48.         }
    
49.        
    
50.         public void setAge(int age){
    
51.                 this.age = age;
    
52.         }
    
53.        
    
54.         public String getName(){
    
55.                 return name;
    
56.         }
    
57.        
    
58.         public void setName(String name){
    
59.                 this.name = name;
    
60.         }
    
61.        
    
62.         @Override
    
63.         public String toString(){
    
64.                 return age+" "+name;
    
65.         }
    
66. }

复制代码

ArrayList里是可以有重复元素的，可以通过HashSet剔除
    // 删除ArrayList中重复元素
    public static void removeDuplicateBySet(List list) {
          HashSet h = new HashSet(list);
          list.clear();
          list.addAll(h);
          System.out.println(list);
    }

看系统调用什么方法，就看集合是什么结构，如：  数组结构的是系统使用a【i】=“”来存储到栈中，  底层是二叉树是，系统会调用hashcode（）和equals（）方法，先赋给他一个hash值，再比较其大小，最后按照二叉树的形式保存起来。

  底层是hash表时，系统也是会有hashcode（）和equals（）方法，先赋hash值，再比较hash是否相等，当相等时，就会将新进来的对象存入，
覆盖掉原来的对象。