== 简单而又实在

在基本数据类型中比较的是两个数据的值。
在对象中比较的是两个对象的地址。

equal 追求的是“逻辑相等”

对大部分的对象来说，使用父类的 Object.equal() 就已经足够使用了。而 Object.equal() 实现的功能就是比较两个对象的地址是不是相同的。

例如我们比较两个 Thread 是不是同一个线程，只要比较他们的地址就可以达到我们的目的了。

但依旧有些类，要求的不是绝对的相同（指向同一个对象），而是需要的逻辑上的相同（感官上觉得这两个类值是相同）。

例如我们常用的 String ，Integer，Data 等，则需要根据他们的特性，去复写一个去判断值是不是相等的 equal() 方法。

复写 equal() 的需要满足：

自反性（reflexive）。对于任何非 null 的引用值 x ，x.equals(x) 必须返回 true 。
对称性（symmetric）。对于任何非 null 的引用值 x 和 y ，当且仅当 y.equals(x) 返回 true 时，x.equals(y) 必须返回 true 。
传递性（transitive）。对于任何非 null 的引用值 x 、 y 和 z 。如果 x.equals(y) 返回 true ，并且 y.equals(z) 也返回 true ，那么 x.equals(z) 也必须返回 true 。
一致性（consistent）。对于任何非 null 的引用值 x 和 y ，只要 equals 的比较操作在对象中所用的信息没有被修改，多次调用 x.equals(x) 就会一致地返回 true ，或者一致的返回 false 。
非空性（Non-nullity）。对于任何非 null 的引用值 x ，x.equals(null) 必须返回 false 。

什么情况会违法对称性呢？
比如说我们在自己的 IgnoreCaseString 类中，复写 equal() 方法，使这个方法在与 String 比较时，忽略 String 的大小写。但在 "Abc".equal(ignoreCaseString1) 在反过来，结果就会出现不同。

public static class IgnoreCaseString {
        private String string;

        public IgnoreCaseString(String str){
            this.string = str;
        }

        @Override
        public boolean equals(Object obj) {
            if (obj instanceof String) {
                return string.equalsIgnoreCase((String) obj);
            }
            return super.equals(obj);
        }

        @Override
        public String toString() {
            return string;
        }
    }

    public static void main(String[] args) {
        String str = "Abc";
        IgnoreCaseString str1 = new IgnoreCaseString("Abc");
        System.out.println(str1.equals(str));// true
        System.out.println(str.equals(str1));// false
    }

什么时候会违法传递性
A，B，C 三个类。A 和 B 同时复写了 equal() 方法时，会出现这种可能。

复写 equal() 尽量不要去想兼容其他类型的比较。而时去判断是否和同一个类是否相同。通常建议这样去判断：
（1）用 == 去判断是否为同个对象
（2）用 instanceof 去判断是否属于同个类或同个接口类型，如 Set，List 这类
（3）检查关键数据是否相同，这点根据自身的需求来处理