1 概述

这三者怎么联系起来的，有交叉--。

• ==关系运算符关系运算符。
• equals()和hashCode()是两个方法。
• 在 equals()和hashCode()可能使用到了==
• JDK对equals(Object obj)和hashcode()这两个方法有定义和规范（往下看）
• 在java原生的哈希表数据结构中经常使用e.hash == hash && key.equals(eKey)来判断是否是“相等” ，因此在这里就将hash 和 equals联系起来了。即：下面会提到的规范。

2 ==关系运算符

2.1 JAVA的运算符

• 分为四类：算数运算符、关系运算符、逻辑运算符、位运算符
• 算数运算符(9)：+ - * / % ++ --
• 关系运算符(6)：== != > >= < <=
• 逻辑运算符(6)：&& || ! ^ & |
• 位运算符(7)：& | ~ ^ >> << >>>；

==是关系运算符

2.2 Java中的数据类型在内存的存储原理

• 1. 基本数据类型的存储原理：所有的简单数据类型不存在“引用”的概念，基本数据类型都是直接存储在内存中的内存栈上**的，数据本身的值就是存储在栈空间里面，Java语言里面八种数据类型是这种存储模型；
     基本数据类型之理解
• 2. 引用类型的存储原理：引用类型继承于Object类（也是引用类型）都是按照Java里面存储对象的内存模型来进行数据存储的，使用Java内存堆和内存栈来进行这种类型的数据存储，简单地讲，“引用”(存储对象在内存堆上的地址)是存储在有序的内存栈上的，而*对象本身的值存储在内存堆上的；
• 基本数据类型和引用类型的区别主要在于基本数据类型是分配在栈上的，而引用类型是分配在堆上的
• 不论是基本数据类型还是引用类型，他们都会先在栈中分配一块内存，对于基本类型来说，这块区域包含的是基本类型的内容；而对于引用类型来说，这块区域包含的是指向真正内容的指针，真正的内容被手动的分配在堆上。

2.3 基本类型转换

2.3.1 自动类型提升(隐式转换),小数据类型向大数据类型转换.

• 在混合运算时,byte、short、char之间不会相互转换，都会自动类型提升为int类型.
• 除byte、short、char外，其他类型进行混合运算的是小的数据类型提升为大的

2.3.2 强制类型转换:想让大数据类型其转换成小数据类型.

• 目标类型 变量名 = (目标类型)(运算结果)
  byte b = (byte)(a + b);
• 注意:如果超出了被赋值的数据类型的取值范围得到的结果会与你期望的结果不同(强转有风险,需谨慎)Byte b = (byte)(300) 结果44

2.2 关系运算符

关系运算符用于比较两个数值之间的大小，其运算结果为一个逻辑类型(boolean布尔类型)的数值。
==关系运算符

• 比较基本数据类型比较的是具体值
• 比较引用数据类型比较的是地址值

3 equals和hashcode的区别和联系

3.1 JDK对equals(Object obj)和hashcode()这两个方法的定义和规范

3.1.1 定义

• 在Java中任何一个对象都具备equals(Object obj)和hashcode()这两个方法，因为他们是在Object类中定义的。
• equals(Object obj)方法用来判断两个对象是否“相同”，如果“相同”则返回true，否则返回false。
• hashcode()方法返回一个int数，在Object类中的默认实现是“将该对象的内部地址转换成一个整数返回”。

3.1.2 关于这两个方法的重要规范

只是抽取了最重要的两个

• 规范1：若重写equals(Object obj)方法，有必要重写hashcode()方法，确保通过equals(Object obj)方法判断结果为true的两个对象具备相等的hashcode()返回值。
• 这个只是规范，如果你非要写一个类让equals(Object obj)返回true而hashcode()返回两个不相等的值，编译和运行都是不会报错的。不过这样违反了Java规范，程序也就埋下了BUG。
• 规范2：如果equals(Object obj)返回false，即两个对象“不相同”，并不要求对这两个对象调用hashcode()方法得到两个不相同的数。
• 根据这两个规范，可以得到如下推论： 1、如果两个对象equals，Java运行时环境会认为他们的hashcode一定相等。 2、如果两个对象不equals，他们的hashcode有可能相等。 3、如果两个对象hashcode相等，他们不一定equals。 4、如果两个对象hashcode不相等，他们一定不equals。

3.2 equals

3.2.1 Object类的equals

Object类中的equals方法和“==”是一样的

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

3.2.1 Integer的equals

    @Override
    public boolean equals(Object o) {
        return (o instanceof Integer) && (((Integer) o).value == value);
    }

3.2.2 String类的equals

    @Override public boolean equals(Object other) {
        if (other == this) {
          return true;
        }
        if (other instanceof String) {
            String s = (String)other;
            int count = this.count;
            if (s.count != count) {
                return false;
            }

            if (hashCode() != s.hashCode()) {
                return false;
            }
            for (int i = 0; i < count; ++i) {
                if (charAt(i) != s.charAt(i)) {
                    return false;
                }
            }
            return true;
        } else {
            return false;
        }
    }

String类，Integer类等等一些类，是重写了equals方法，才使得equals和“==不同”，所以，当自己创建类时，自动继承了Object的equals方法，要想实现不同的等于比较，必须重写equals方法。

3.2.3 自己实现equals坚持一般的规范

当你重写equals方法时，必须遵守它的通用约定。

• 自反性：对于任何非空引用x，x.equals(x)必须返回true。
• 对称性：对于任何非空引用x和y，如果且仅当y.equals(x)返回true时x.equals(y)必须返回true。
• 传递性：对于任何非空引用x、y、z，如果x.equals(y)返回true，y.equals(z)返回true，则x.equals(z)必须返回true。
• 一致性：对于任何非空引用x和y，如果在equals比较中使用的信息没有修改，则x.equals(y)的多次调用必须始终返回true或始终返回false。
• 对于任何非空引用x，x.equals(null)必须返回false。

3.2.4 重写配方

1. 使用= =运算符检查参数是否为该对象的引用。如果是，返回true。这只是一种性能优化，但是如果这种比较可能很昂贵的话，那就值得去做。
2. 使用instanceof运算符来检查参数是否具有正确的类型。 如果不是，则返回false。
3. 参数转换为正确的类型。因为转换操作在instanceof中已经处理过，所以它肯定会成功
4. 对于类中的每个“重要”的属性，请检查该参数属性是否与该对象对应的属性相匹配。如果所有这些测试成功，返回true，否则返回false。如果步骤2中的类型是一个接口，那么必须通过接口方法访问参数的属性;如果类型是类，则可以直接访问属性，这取决于属性的访问权限。

3.2.5 示例

public final class PhoneNumber {

    private final short areaCode, prefix, lineNum;

    public PhoneNumber(int areaCode, int prefix, int lineNum) {
        this.areaCode = rangeCheck(areaCode, 999, "area code");
        this.prefix = rangeCheck(prefix, 999, "prefix");
        this.lineNum = rangeCheck(lineNum, 9999, "line num");
    }

    private static short rangeCheck(int val, int max, String arg) {
        if (val < 0 || val > max)
            throw new IllegalArgumentException(arg + ": " + val);
        
        return (short) val;
    }

    @Override
    public boolean equals(Object o) {
        if (o == this)
            return true;
        if (!(o instanceof PhoneNumber))
            return false;

        PhoneNumber pn = (PhoneNumber) o;

        return pn.lineNum == lineNum && pn.prefix == prefix
                && pn.areaCode == areaCode;
    }

    ... // Remainder omitted
}

以下是一些最后提醒：

• 1. 当重写equals方法时，同时也要重写hashCode方法。
• 2. 不要让equals方法试图太聪明。如果只是简单地测试用于相等的属性，那么要遵守equals约定并不困难。如果你在寻找相等方面过于激进，那么很容易陷入麻烦。一般来说，考虑到任何形式的别名通常是一个坏主意。例如，File类不应该试图将引用的符号链接等同于同一文件对象。幸好 File 类并没这么做。
• 3. 在equal 时方法声明中，不要将参数Object替换成其他类型。对于程序员来说，编写一个看起来像这样的equals方法并不少见，然后花上几个小时苦苦思索为什么它不能正常工作.

4 hashCode

4.1 hashCode方法的描述

返回该对象的哈希码值。支持此方法是为了提高哈希表（例如java.util.Hashtable提供的哈希表）的性能。

4.2 hashCode的常规协定

• 在 Java 应用程序执行期间，在对同一对象多次调用hashCode方法时，必须一致地返回相同的整数，前提是将对象进行equals比较时所用的信息没有被修改。从某一应用程序的一次执行到同一应用程序的另一次执行，该整数无需保持一致。
• 如果根据equals(Object)方法，两个对象是相等的，那么对这两个对象中的每个对象调用hashCode方法都必须生成相同的整数结果。
• 如果根据equals(java.lang.Object)方法，两个对象不相等，那么对这两个对象中的任一对象上调用hashCode方法不要求一定生成不同的整数结果。但是，程序员应该意识到，为不相等的对象生成不同整数结果可以提高哈希表的性能。

4.3 java中数据结构hash和equals的使用

• 通常使用e.hash == hash && key.equals(eKey)来比较两个引用是否“相等”。

java原生数据结构源码待看。看完补充。

参考

Java 基本数据类型 及 == 与 equals 方法的区别
java中hashcode和equals的区别和联系
Effective Java 第三版——10. 重写equals方法时遵守通用约定