一个简单的面试题 equals和==的区别

equals比较

看下下面这个输出结果：

        String s1 = "你好";
        String s2 = "hello";
        String s3 = new String(s1 + s2);
        String s4 = s1 + s2;
        String s5 = "你好hello";
        String s6 = new String(s5);
        String s7 = "你好"+s2;
        String s8 = "你好"+"hello";


        //比较equals
        System.out.println(s3.equals(s4));
        System.out.println(s3.equals(s6));
        System.out.println(s5.equals(s4));
        System.out.println(s5.equals(s6));

很明显输出结果都是true,那么结果是什么原因呢，首先需要了解的一点是equals这个方法本身是Object这个super 父类自带的方法

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

默认会去通过==来比较两个对象是否相等，而上面的equasl比较是通过String类型进行比较的，很明显String类是重写了Object类的equals方法的，String类的equals方法如下：

  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;
    }

String的equals方法会首先通过==比较两个对象是否执行同一块堆内存空间，如果内存空间地址不一样会通过遍历比较字符串字符是否相等

通过String重写的Equals方法，也可以明白我们在实际开发中自定义的对象，通常也会重写eqauls方法，并且也会重写hashCode方法，同样我们也拿String做例子，查看String的hashCode方法

 public int hashCode() {
   //String 默认hash值是0
        int h = hash;
        if (h == 0 && value.length > 0) {
            char val[] = value;

            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];
            }
            hash = h;
        }
        return h;
    }

我们通过自定义一个类来分析Equals和HashCode的关系，这个问题在对于初级开发人员来说，也是一个比较常见的问题

public class Person {

    private String name;
    private String idNum;
    private Integer age;

    public Person(String name, String idNum, Integer age) {
        this.name = name;
        this.idNum = idNum;
        this.age = age;
    }
    .....
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Person)) return false;
        Person person = (Person) o;
        return getName().equals(person.getName()) &&
                getIdNum().equals(person.getIdNum()) &&
                getAge().equals(person.getAge());
    }

    @Override
    public int hashCode() {
        return Objects.hash(getName(), getIdNum());
    }

 }
    

测试如下：

   public static void main(String[] args) {
        Person p1= new Person("张三","100001",22);
        Person p2= new Person("张三","100001",12);
        System.out.println(p1.equals(p2));
        System.out.println(p1.hashCode()==p2.hashCode());
    }

很明显 equals肯定是不相等的，但是hashCode值是相等的，这个只是一特例，你可以参考HashMap的 put源码 为什么 插入数据的时候hash值相等还是需要比较key值是否相等呢？

在思考equals方法和hashcode方法时，你可以是思考hash桶，在学习哈希表的时候，我们都知道 在往hash表插入数据的时候是会产生哈希碰撞的，就是因为在插入数据的时候需要定位要插入的位置index下标，这个时候做的操作就是hash计算 计算你的hash值在哈希表所对应的下标，这个下标计算出来的结果是会出现相同的，也就是哈希碰撞，这个时候就需要再次equals方法比较两个值是否相同，如果相同就可以直接覆盖，否则就依链表的形式尾部追加。 其实上面的情况在HashMap里是一样的，hash值相等并不代表两个对象相等，因为hashcode方法重写后并不保证你的equals相等，那么问题来了 equals相等为什么就一定会保证hashcode是相等的呢，既然equals方法和hashcode方法都可以重写，看上去确实挺有道理的。我们继续用上面的Person类为例继续讲解。
首先如果我们定义一个equals相等,但是hashcode值不相等，会出现什么情况，我们一探·究竟。

 @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Person)) return false;
        Person person = (Person) o;
        return getName().equals(person.getName()) &&
                getIdNum().equals(person.getIdNum());
    }

    @Override
    public int hashCode() {
        return Objects.hash(getName(),getIdNum(), getAge());
    }

这时我们测试如下：

  public static void main(String[] args) {
        Person p1= new Person("张三","100001",22);
        Person p2= new Person("张三","100001",12);
        System.out.println(p1.equals(p2));
        System.out.println(p1.hashCode()==p2.hashCode());

        HashSet<Person> peoples = new HashSet<>();
        peoples.add(p1);
        peoples.add(p2);
        System.out.println(peoples.size());
    }

这时的输出为：

true
false
2
这是不是就违背了我们HashMap的原理了，在往Haset里面add对象的时候，HashSet的底层还是使用的是HashMap，里HashMap的Key对象不重复的特点，如果你将上面的代码debug调试你就会发现问题。

看HashMap putVal这个方法代码

 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
        ....
       }
}

第一次add的时候 结果如下

n=16 初始化hashMap 新增的第一个person在map没有相同的 得到的p = tab[i = (n - 1) & hash]) ===null 其中i=(n - 1) & hash]=6 会在index下标为6的hash表中插入person对象

第二次插入对象的时候 因为hash值不相等 索引这次计算的 i = (n - 1) & hash 不是6 而是12 所以会往hash 表下标为12的位置插入这个新的person对象

首先这明显是违背了相等对象插入到不同位置这一个定论，我们实际开发中在自定义实现equals方法时都会去重写hashcode来保证一致，如果hashcode的结果不相等 但是equls相等 ， 我们在实际开发中都会通过equals方法来比较两个对象是否相等，那么现在正如上面所出现的一样，两个对象相等但是在hashSet中确可以同时插入，很明显违背了这一个原则。所以我们总说的两个对象equals相等 hashcode必须相等也可以从这里得到论证。

==比较对象的意义

上面也说了equals方法在Object中默认就是通过==来比较两个对象是否相等的，只不过我们自己创建的对象会重写这个方法。那么 = = 比较对象的意义是什么。我们一样通过String对象来学习，还是上面的String比较

	String s1 = "你好";
	String s2 = "hello";
	String s3 = new String(s1 + s2);
	String s4 = s1 + s2;
	String s5 = "你好hello";
	String s6 = new String(s5);
	String s7 = "你好"+s2;
	String s8 = "你好"+"hello";
	
	System.out.println(s3==s4);
	System.out.println(s3==s6);
	System.out.println(s5==s4);
	System.out.println(s5==s6);
	System.out.println(s7==s8);
	System.out.println(s7==s4);
	System.out.println(s4==s8);
	System.out.println(s5==s8);

输出结果如下：

false
false
false
false
false
false
false
true

首先分析一下为什么s5=s8这个要根据常量池来讲解了，因为第一点你好 hello他们都是常量，是会存储在常量池的，这一点就跟Integer一样 Integer整形常量里面的值的范围是-128到127，这个范围内比较值==是相等的，因为都在常量池里面存储

那么开始从头分析，首先是 s3= =s4 这个肯定是false 毋庸置疑的，一个是字符串拼接而成，另外一个则是新开辟一块内存空间指向对象，而s3= =s6 同样 s6也是开辟一块内存空间，所以内存空间地址是不一样的 ；s5==s4 这两个不相等 我认为是因为s4是两个常量拼接而成 ，然后s5是直接取的常量池的"你好 hello" 所以地址指向不同 ，而s4!=s7和s8!=s4原因和s5!=s4是一样的。

创作不易，如果对你有帮助，帮忙点个赞呗。