面试最容易被问到的==和equals的区别你废了吗

==比较

==是java中一种操作符，他有两种方式比较

1.对于基本数据类型来说 ==判断的是两边的值是否相等，例如：

  int a = 10;
  int b = 10;
  System.out.println(a==b);

2.对于应用类型来说，==判断的是两边的引用是否相等，也就是判断两个对象是否执行了同一块内存区域。

public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

        Person p1 = new Person("tom", 12);
        Person p2 = new Person("jack", 12);
        System.out.println(p1.getName().equals(p2.getName()));
        System.out.println(p1.getAge() == p2.getAge());

结果分析

equals方法

equals是java中所有对象的父类，即Object类定义的一个方法，它只能比较对象，它表示的是引用双方的值是否相等。所以并不是说==比较的就是引用是否相等，equals比较的就是值相等，需要区分来说

equals 用作对象之间的比较具有如下特性：

自反性︰对于任何非空引用×来说, x.equals(x)应该返回true。

对称性∶对于任何非空引用x和y来说，若x.equals (y)为true，则y.equals (x)也为true。

传递性∶对于任何非空引用的值来说，有三个值，x、y和z，如果x.equals(y)返回true,y.equals(z)返回true，那么x.equals(z)也应该返回true。

一致性∶对于任何非空引用×和y来说，如果x.equals(y)相等的话，那么它们必须始终相等。

非空性︰对于任何非空引用的值x来说，x.equals(null)必须返回false。

String中的equals是如何重写的

String代表的是java中的字符串，String类比较特殊，它整个类都是被final修饰的，也就是说，String不能被任何类继承，任何修改String字符串的方法都是创建了一个新的字符串。

equals方法是Object类定义的方法，Object是所有类的父类，当然也包括String，String重写了equals方法，下面来看看怎样重写的

/**
     * Compares this string to the specified object.  The result is {@code
     * true} if and only if the argument is not {@code null} and is a {@code
     * String} object that represents the same sequence of characters as this
     * object.
     *
     * <p>For finer-grained String comparison, refer to
     * {@link java.text.Collator}.
     *
     * @param  anObject
     *         The object to compare this {@code String} against
     *
     * @return  {@code true} if the given object represents a {@code String}
     *          equivalent to this string, {@code false} otherwise
     *
     * @see  #compareTo(String)
     * @see  #equalsIgnoreCase(String)
     */
    public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String aString = (String)anObject;
            if (coder() == aString.coder()) {
                return isLatin1() ? StringLatin1.equals(value, aString.value)
                                  : StringUTF16.equals(value, aString.value);
            }
        }
        return false;
    }

解释：

首相会判断比较两个字符串他们的引用是否相等，如果相等的话，直接返回 true 不相等的话继续下⾯的判断

然后再判断被比较的对象是否是String的实例，如果不是的话直接返回false，如果是的话，再比较两个字符串的长度是否相等，如果长度不相等的话就没必要再比较，直接返回false，长度相等就会比较字符创中的每个字符是否相等，如果其中有一个字符不相等，就会直接返回false

以下是它的流程图：

为什么重写equals方法必须重写hashCode方法

因为equals方法是用来比较对象大小是否相等的方法，hashCode方法是用来判断每个对象hash值得一种方法。如果只写equals方法而不重写hashCode方法，很有可能造成两个不同的对象，它们的hashCode也相等比如以下代码，它们的hashCode相等，equals不相等

以下是hashCode JavaAPI中的定义

总结起来就是

 

1. 如果在 Java 运⾏期间对同⼀个对象调⽤ hashCode ⽅法后，⽆论调⽤多少次，都应该返回相同的  hashCode，但是在不同的 Java 程序中，执⾏ hashCode ⽅法返回的值可能不⼀致。

2.如果两个对象的 equals 相等，那么 hashCode 必须相同

3.如果两个对象 equals 不相等，那么 hashCode 也有可能相同，所以需要重写 hashCode ⽅法，因 为你不知道 hashCode 的底层构造（反正我是不知道，有⼤⽜可以传授传授），所以你需要重写

hashCode ⽅法，来为不同的对象⽣成不同的 hashCode 值，这样能够提⾼不同对象的访问速度。

4.hashCode 通常是将地址转换为整数来实现的。