Java基础（核心）2： == 与 equals 与 hashCode

1：== 与 equals（）(重要)

    == : 它的作用是判断两个对象的地址是不是相等
    判断两个对象是不是同一个对象(基本数据类型==比较的是值，引用数据类型==比较的是内存地址)。
    equals() : 它的作用也是判断两个对象是否相等。
        两种使用情况：
        情况 1：类没有覆盖 equals() 方法。则通过 equals() 比较该类的两个对象时，等价于通过“==”比较这两个对象。
        情况 2：类覆盖了 equals() 方法。一般，我们都覆盖 equals() 方法判断来两个对象的内容相等；
                  若它们的内容相等，则返回 true (即，认为这两个对象相等)。
        注意：String的equal方法时经过重写的

   //String中重写的euqals方法
   public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

2：hashCode（）介绍

    hashCode()在散列表中才有用，在其它情况下没用。
   在散列表中 hashCode() 的作用是获取对象的哈希码（散列码），进而确定该对象在散列表中的位置。
    hashCode() 的作用是获取哈希码，也称为散列码；
    它实际上是返回一个 int 整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。
    hashCode() 定义在 JDK 的 Object.java 中，这就意味着 Java 中的任何类都包含有 hashCode() 函数。
    散列表存储的是键值对(key-value)，它的特点是：能根据“键”快速的检索出对应的“值”。
    以“HashSet 如何检查重复”为例子来说明为什么要有 hashCode：
    当你把对象加入 HashSet 时，
    HashSet 会先计算对象的 hashcode 值来判断对象加入的位置，同时也会与其他已经加入的对象的 hashcode 值作比较；
   如果没有相符的 hashcode，HashSet 会假设对象没有重复出现。
    如果发现有相同 hashcode 值的对象，这时会调用 equals（）方法来检查 hashcode 相等的对象是否真的相同。
        如果两者相同，HashSet 就不会让其加入操作成功。
        如果不同的话，就会重新散列到其他位置。

3：hashCode（）与 equals（）

对于hashCode（）与 equals（）的关系  需要分两种情况讨论
第一种 不会创建“类对应的散列表”
        这里所说的“不会创建类对应的散列表”是说：
        我们不会   不会在HashSet, Hashtable, HashMap等等这些本质是散列表的数据结构中  使用 hashCode()
            equals() 用来比较该类的两个对象是否相等。
            hashCode() 则根本没有任何作用，所以，不用理会hashCode()。

import java.util.*;
import java.lang.Comparable;
public class NormalHashCodeTest{
    public static void main(String[] args) {
        // 新建2个相同内容的Person对象，
        // 再用equals比较它们是否相等
        Person p1 = new Person("eee", 100);
        Person p2 = new Person("eee", 100);
        Person p3 = new Person("aaa", 200);
        System.out.printf("p1.equals(p2) : %s; p1(%d) p2(%d)\n", p1.equals(p2), p1.hashCode(), p2.hashCode());
        System.out.printf("p1.equals(p3) : %s; p1(%d) p3(%d)\n", p1.equals(p3), p1.hashCode(), p3.hashCode());
    }
    private static class Person {
        int age;
        String name;
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
        /**
         * @desc 覆盖equals方法
         */
        public boolean equals(Object obj){
            if(obj == null){
                return false;
            }
            //如果是同一个对象返回true，反之返回false
            if(this == obj){
                return true;
            }
            //判断是否类型相同
            if(this.getClass() != obj.getClass()){
                return false;
            }
            Person person = (Person)obj;
            return name.equals(person.name) && age==person.age;
        }
    }
}
//p1.equals(p2) : true; p1(1169863946) p2(1901116749)
//p1.equals(p3) : false; p1(1169863946) p3(2131949076)

   第二种 会创建“类对应的散列表”    
    这里所说的“会创建类对应的散列表”是说：
    我们会在HashSet, Hashtable, HashMap等等这些本质是散列表的数据结构中
        如果两个对象相等，则 hashcode 一定也是相同的;
        两个对象相等,对两个对象分别调用 equals 方法都返回 true;
        两个对象有相同的 hashcode 值，它们也不一定是相等的（不同的对象也可能产生相同的 hashcode，哈希冲突）;
        在这种情况下，除了要覆盖equals()之外，也要覆盖hashCode()函数
        hashCode() 的默认行为是对堆上的对象产生独特值。
        如果没有重写 hashCode()，则该 class 的两个对象无论如何都不会相等（即使这两个对象指向相同的数据）

public class ConflictHashCodeTest{
    public static void main(String[] args) {
        // 新建Person对象，
        Person p1 = new Person("eee", 100);
        Person p2 = new Person("eee", 100);
        Person p3 = new Person("EEE", 100);
        // 新建HashSet对象
        HashSet set = new HashSet();
        set.add(p1);
        set.add(p2);
        set.add(p3);
        // 比较p1 和 p2， 并打印它们的hashCode()
        System.out.printf("p1.equals(p2) : %s; p1(%d) p2(%d)\n", p1.equals(p2), p1.hashCode(), p2.hashCode());
        // 比较p1 和 p3， 并打印它们的hashCode()
        System.out.printf("p1.equals(p4) : %s; p1(%d) p4(%d)\n", p1.equals(p3), p1.hashCode(), p3.hashCode());
        // 打印set
        System.out.printf("set:%s\n", set);
    }
    private static class Person {
        int age;
        String name;
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
        /**
         * @desc重写hashCode
         */
        @Override
        public int hashCode(){
            int nameHash =  name.toUpperCase().hashCode();
            return nameHash ^ age;
        }
        /**
         * @desc 覆盖equals方法
         */
        @Override
        public boolean equals(Object obj){
            if(obj == null){
                return false;
            }
            //如果是同一个对象返回true，反之返回false
            if(this == obj){
                return true;
            }
            //判断是否类型相同
            if(this.getClass() != obj.getClass()){
                return false;
            }
            Person person = (Person)obj;
            return name.equals(person.name) && age==person.age;
        }
    }
}
//p1.equals(p2) : true; p1(68545) p2(68545)
//p1.equals(p3) : false; p1(68545) p3(68545)
// 比较p1和p2，我们发现：它们的hashCode()相等，通过equals()比较它们也返回true。所以，p1和p2被视为相等。
//因此p1 set进去后 p2不能set进去
//比较p1和p3，我们发现：虽然它们的hashCode()相等；但是，通过equals()比较它们返回false。所以，p1和p3被视为不相等。 
//因此p1 set进去后 p3还能set进去

4：== 与 equal 与 hashcode 总结

== ：基本数据类型的值  引用数据类型地址
equal：没被重写  判断逻辑  与== 一致
         被重写判   判断逻辑 为判断内容
hashcode ：经过hash 运算生成的值
1：hashcode不经过重写完全没意义
2：如果不是  之后使用在HashSet, Hashtable, HashMap  则hashcode值完全没意义
3：在hashcode 经过重写  并且 在之后使用在HashSet, Hashtable, HashMap
    如果是则hashcode一致  内容不一定完全相等   对象也就不一定相等（哈希运算算法 字母大写（换小写） 与 字母小写）
   在通过重写的equal比较  如果还是一致            对象才一定相等  
    通常在hash表中会先进行 hashcode的比较（更快）  再进行equal的比较