Java集合类总结4——==/equals/hashCode()/compareTo()

==/equals()/hashCode()/compareTo()总结

1、==：用于比较引用和比较基本数据类型时具有不同的功能：
(a).比较基本数据类型，如果两个值相同，则结果为true;
(b).而在比较引用时，如果引用指向内存中的同一对象，结果为true

2、equals():
1) 首先equals()和hashcode()这两个方法都是从object类中继承过来的。equals()方法在object类中定义如下：

public boolean equals(Object obj) {  
    return(this == obj);  
    }  

很明显是对两个对象的地址值进行的比较（即比较引用是否相同）。

2)但是我们必需清楚，当String、Math、还有Integer、Double。。。。等这些封装类在使用equals()方法时，已经覆盖了object类的equals（）方法。
比如在String类中如下：

 publicboolean equals(Object anObject) {  
    if (this == anObject) {  
    return true;  
    }  
    if (anObject instanceof String) {  
    String anotherString = (String)anObject;  
    int n =count;  
    if (n == anotherString.count) {  
    char v1[] =value;  
    char v2[] = anotherString.value;  
    int i =offset;  
    int j = anotherString.offset;  
    while (n-- !=0) {  
    if (v1[i++] != v2[j++])  
    returnfalse;  
    }  
    return true;  
    }  
    }  
    returnfalse;  
    } 

很明显，这是进行的内容比较，而已经不再是地址的比较。依次类推Double、Integer、Math。。。。等等这些类都是重写了equals()方法的，从而进行的是内容的比较。


3、hashCode()

1)在object类中定义如下：

public native int hashCode();

说明是一个本地方法，它的实现是根据本地机器相关的。

未重写相应方法，在object类中，hashcode()方法是本地方法，返回的是对象的地址值，而object类中的equals()方法比较的也是两个对象的地址值，如果equals()相等，说明两个对象地址值也相等，当然hashcode()也就相等了；

2) 当然我们可以在自己写的类中覆盖hashcode()方法，比如String、Integer、Double。。。。等等这些类都是覆盖了hashcode()方法的。例如在String类中定义的hashcode()方法如下：

 public int hashCode() {  
    inth = hash;  
    If(h == 0) {  
    intoff = offset;  
    charval[] = value;  
    intlen = count;  
    for(int i = 0; i < len; i++) {  
    h = 31*h + val[off++];  
    }  
    hash = h;  
    }  
    returnh;  
    }

解释一下这个程序（String的API中写到）：s[0]*31^(n-1)+ s[1]*31^(n-2) + ... + s[n-1]

使用int算法，这里s[i]是字符串的第i个字符，n是字符串的长度，^表示求幂。

在string类中重写了这两个方法，equals()返回的是两个对象内容的比较，当两个对象内容相等时， Hashcode()方法根据String类的重写（第2点里面已经分析了）代码的分析，也可知道hashcode()返回结果也会相等。以此类推，可以知道Integer、Double等封装类中经过重写的equals()和hashcode()方法也同样适合于这个原则。当然没有经过重写的类，在继承了object类的equals()和hashcode()方法后，也会遵守这个原则。

4、hashCode()的作用

这里我们首先要明白一个问题：
equals()相等的两个对象，hashcode()一定相等；
equals()不相等的两个对象，却并不能证明他们的hashcode()不相等,即equals()方法不相等的两个对象，hashcode()有可能相等。（我的理解是由于哈希码在生成的时候产生冲突造成的）；

反过来说：
hashcode()不等，一定能推出equals()也不等；
hashcode()相等，equals()可能相等，也可能不等。


hashset,hashmap, hashtable中的使用，请看如下分析：
Hashset是继承Set接口，Set接口又实现Collection接口，这是层次关系。那么hashset是根据什么原理来存取对象的呢？在Java的集合中，判断两个对象是否相等的规则是：
1)，判断两个对象的hashCode是否相等
如果不相等，认为两个对象也不相等，完毕
如果相等，转入2)
2)，判断两个对象用equals运算是否相等
如果不相等，认为两个对象也不相等
如果相等，认为两个对象相等（equals()是判断两个对象是否相等的关键）
为什么是两条准则，难道用第一条不行吗？不行，因为前面已经说了，hashcode()相等时，equals()方法也可能不等，所以必须用第2条准则进行限制，才能保证加入的为非重复元素。

比如下面的代码：

public static void main(String args[]){  
    Strings1=new String("zhaoxudong");   
    Strings2=newString("zhaoxudong");   
    System.out.println(s1==s2);//false   
    System.out.println(s1.equals(s2));//true   
    System.out.println(s1.hashCode());//s1.hashcode()等于s2.hashcode()   
    System.out.println(s2.hashCode());   
    Set hashset=new HashSet();   
    hashset.add(s1);   
    hashset.add(s2);   

/*实质上在添加s1,s2时，运用上面说到的两点准则，可以知道hashset认为s1和s2是相等的，是在添加重复元素，所以让s2覆盖了s1;*/
Iteratorit=hashset.iterator();
           while(it.hasNext())
           {
            System.out.println(it.next());
           }
} 

最后在while循环的时候只打印出了一个”zhaoxudong”。
输出结果为：false
           true
           -967303459
           -967303459
这是因为String类已经重写了equals()方法和hashcode()方法，所以在根据上面的第1.2条原则判定时，hashset认为它们是相等的对象，进行了重复添加。
但是看下面的程序：


   

importjava.util.*;   
    publicclass HashSetTest   
    {   
      publicstatic void main(String[] args)   
       {   
                    HashSeths=new HashSet();   
                    hs.add(new Student(1,"zhangsan"));   
                    hs.add(new Student(2,"lisi"));   
                    hs.add(new Student(3,"wangwu"));   
                    hs.add(new Student(1,"zhangsan"));   
        
                    Iteratorit=hs.iterator();   
                    while(it.hasNext())   
                    {   
                           System.out.println(it.next());   
                    }   
        }   
    }   
    class Student{   
        int num;   
        String name;   
        Student(intnum,String name){   
            this.num=num;   
            this.name=name;   
        }   
        publicString toString(){   
            returnnum+":"+name;   
        }   
    }        
    输出结果为：   
                         1:zhangsan   
                      1:zhangsan   
                      3:wangwu   
                      2:lisi   

问题出现了，为什么hashset添加了相等的元素呢，这是不是和hashset的原则违背了呢？回答是：没有
因为在根据hashcode()对两次建立的newStudent(1,"zhangsan")对象进行比较时，生成的是不同的哈希码值，所以hashset把他当作不同的对象对待了，当然此时的equals()方法返回的值也不等（这个不用解释了吧）。那么为什么会生成不同的哈希码值呢？上面我们在比较s1和s2的时候不是生成了同样的哈希码吗？原因就在于我们自己写的Student类并没有重新自己的hashcode()和equals()方法，所以在比较时，是继承的object类中的hashcode()方法。
它是一个本地方法，比较的是对象的地址（引用地址），使用new方法创建对象，两次生成的当然是不同的对象了，造成的结果就是两个对象的hashcode()返回的值不一样。所以根据第一个准则，hashset会把它们当作不同的对象对待，自然也用不着第二个准则进行判定了。那么怎么解决这个问题呢？？
答案是：在Student类中重新hashcode()和equals()方法。
例如：
 

   classStudent   
    {   
    intnum;   
    Stringname;   
    Student(intnum,String name)   
    {   
               this.num=num;   
               this.name=name;   
    }   
    publicint hashCode()   
    {   
               returnnum*name.hashCode();   
    }   
    publicboolean equals(Object o)   
    {   
               Students=(Student)o;   
               returnnum==s.num && name.equals(s.name);   
    }   
    publicString toString()   
    {   
               returnnum+":"+name;   
    }   
    }

      根据重写的方法，即便两次调用了newStudent(1,"zhangsan")，我们在获得对象的哈希码时，根据重写的方法hashcode()，获得的哈希码肯定是一样的。
当然根据equals()方法我们也可判断是相同的。所以在向hashset集合中添加时把它们当作重复元素看待了。所以运行修改后的程序时，我们会发现运行结果是：
                     1:zhangsan
                  3:wangwu
                  2:lisi
可以看到重复元素的问题已经消除。

5)对象实现comparable，重写CompareTo()可保证向TreeSet中添加数据的不同