java基础— ==和equals方法

java基础— ==和equals方法

1.1、==和equals方法

  Java程序中测试两个变量是否相等有两种方式：一种是利用“ = = ”运 算符， 另一种是利用equals()方法。 当使用==来判断两个变量是否相 等时，如果两个变量是基本类型变量，且都是数值类型（不一定要求 数据类型严格相同），则只要两个变量的值相等，就将返回true。
  但对于两个引用类型变量， 只有它们指向同一个对象时， “ = = ”判断 才会返回true。 “ = = ”不可用于比较类型上没有父子关系的两个对象。 下面程序示范了使用“ = = ”来判断两种类型变量是否相等的结果。

    public static void main(String[] args) {
        int it = 65;
        float fl = 65.0f;
        // 将输出true
        System.out.println("65和65.0f是否相等？" + (it == fl));
        char ch = 'A';
        // 将输出true
        System.out.println("65和'A'是否相等？" + (it == ch));
        String str1 = new String("hello");
        String str2 = new String("hello");
        // 将输出false
        System.out.println("str1和str2是否相等？"
                + (str1 == str2));
        // 将输出true
        System.out.println("str1是否equals str2？"
                + (str1.equals(str2)));
        // 由于java.lang.String与EqualTest类没有继承关系，
        // 所以下面语句导致编译错误
		System.out.println("hello" == new EqualTest());
    }

  运行上面程序， 可以看到65、65.0f和’A’相等。 但对于str1和 str2，因为它们都是引用类型变量，它们分别指向两个通过new关键字 创建的String对象，因此str1和str2两个变量不相等。
  对初学者而言，String还有一个非常容易迷惑的地方：“hello"直接量和new String(“hello”)有什么区别呢？当Java程序直接使用形 如"hello” 的字符串直接量（包括可以在编译时就计算出来的字符串值 ）时 ，JVM将会使用常量池来管理这些字符串 ； 当使用new String(“hello”)时，JVM会先使用常量池来管理"hello"直接量，再调用String类的构造器来创建一个新的String对象， 新创建的String对象被保存在堆内存中。换句话说，new String(“hello”)一共产生了两 个字符串对象。
ps：常量池（constant pool）专门用于管理在编译时被确定并被保 存在已编译的.class文件中的一些数据。它包括了关于类、方法、 接口中的常量，还包括字符串常量。
  下面程序示范了JVM使用常量池管理字符串直接量的情形。

    public static void main(String[] args) {
        // s1直接引用常量池中的"疯狂Java"
        String s1 = "疯狂Java";
        String s2 = "疯狂";
        String s3 = "Java";
        // s4后面的字符串值可以在编译时就确定下来
        // s4直接引用常量池中的"疯狂Java"
        String s4 = "疯狂" + "Java";
        // s5后面的字符串值可以在编译时就确定下来
        // s5直接引用常量池中的"疯狂Java"
        String s5 = "疯" + "狂" + "Java";
        // s6后面的字符串值不能在编译时就确定下来，
        // 不能引用常量池中的字符串
        String s6 = s2 + s3;
        // 使用new调用构造器将会创建一个新的String对象，
        // s7引用堆内存中新创建的String对象
        String s7 = new String("疯狂Java");
        System.out.println(s1 == s4); // 输出true
        System.out.println(s1 == s5); // 输出true
        System.out.println(s1 == s6); // 输出false
        System.out.println(s1 == s7); // 输出false
    }

  JVM常量池保证相同的字符串直接量只有一个， 不会产生多个副 本。例子中的s1、s4、s5所引用的字符串可以在编译期就确定下来， 因此它们都将引用常量池中的同一个字符串对象。
  使用new String()创建的字符串对象是运行时创建出来的， 它被保存在运行时内存区（即堆内存）内，不会放入常量池中。
  但在很多时候， 程序判断两个引用变量是否相等时， 也希望有一 种类似于“值相等”的判断规则，并不严格要求两个引用变量指向同 一个对象。例如对于两个字符串变量，可能只是要求它们引用字符串 对象里包含的字符序列相同即可认为相等。 此时就可以利用String对 象 的 equals() 方 法 来 进 行 判 断 ， 例 如 上 面 程 序 中 的 str1.equals（str2）将返回true。
  equals()方法是Object类提供的一个实例方法， 因此所有引用变量都可调用该方法来判断是否与其他引用变量相等。但使用这个方法判断两个对象相等的标准与使用==运算符没有区别，同样要求两个引用变量指向同一个对象才会返回true。 因此这个Object类提供的 equals()方法没有太大的实际意义， 如果希望采用自定义的相等标准，则可采用重写equals方法来实现。
ps：String已经重写了Object的equals()方法， String的equals() 方法判断两个字符串相等的标准是：只要两个字符串所包含的字符 序列相同，通过equals()比较将返回true，否则将返回false。
  下面程序示例重写Person类的equals()方法。

class Person {
    private String name;
    private String idStr;

    public Person() {
    }

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

    public String getName() {
        return name;
    }

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

    public String getIdStr() {
        return idStr;
    }

    public void setIdStr(String idStr) {
        this.idStr = idStr;
    }

    // 重写equals()方法，提供自定义的相等标准
    public boolean equals(Object obj) {
        // 如果两个对象为同一个对象
        if (this == obj)
            return true;
        // 只有当obj是Person对象
        if (obj != null && obj.getClass() == Person.class) {
            Person personObj = (Person) obj;
            // 并且当前对象的idStr与obj对象的idStr相等才可判断两个对象相等
            if (this.getIdStr().equals(personObj.getIdStr())) {
                return true;
            }
        }
        return false;
    }
}

public class OverrideEqualsRight {
    public static void main(String[] args) {
        Person p1 = new Person("孙悟空", "12343433433");
        Person p2 = new Person("孙行者", "12343433433");
        Person p3 = new Person("孙悟饭", "99933433");
        // p1和p2的idStr相等，所以输出true
        System.out.println("p1和p2是否相等？" + p1.equals(p2));
        // p2和p3的idStr不相等，所以输出false
        System.out.println("p2和p3是否相等？" + p2.equals(p3));
    }
}

  上面程序重写Person类的equals()方法， 指定了Person对象和其 他对象相等的标准：另一个对象必须是Person类的实例， 且两个 Person对象的idStr相等，即可判断两个Person对象相等。在这种判断标准下， 可认为只要两个Person对象的身份证字符串相等， 即可判断相等。
  通常而言，正确地重写equals()方法应该满足下列条件。
  ➢ 自反性：对任意x, x.equals(x)一定返回true。
  ➢ 对 称 性 ： 对 任 意 x 和 y, 如 果 y.equals(x) 返 回 true ，则 x.equals(y)也返回true。
  ➢ 传 递 性 ： 对 任 意 x, y, z, 如 果 x.equals(y) 返 回 ture ， y.equals(z)返回true，则x.equals(z)一定返回true。
  ➢ 一致性：对任意x和y, 如果对象中用于等价比较的信息没有改 变, 那么无论调用x.equals(y)多少次，返回的结果应该保持一 致，要么一直是true，要么一直是false。
  ➢ 对任何不是null的x, x.equals(null)一定返回false。 Object默认提供的equals()只是比较对象的地址， 即Object类的 equals()方法比较的结果与==运算符比较的结果完全相同。 因此， 在 实际应用中常常需要重写equals()方法， 重写equals方法时， 相等条 件是由业务要求决定的， 因此equals()方法的实现也是由业务要求决 定的。

1.2、equals()和hashcode()

  equals(): 用来判断两个对象是否相同，再Object类中是通过判断对象间的内存地址来决定是否相同。
  hashCode(): 获取哈希码，也称为散列码，返回一个int整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。

  从Jdk源码的注释中可以看出，hashCode() 在散列表中才会发挥作用，当对象不会用于创建像HashMap、HashSet等集合时，可以不用重写hashCode方法，但是如果有使用到对象的哈希集合等操作时，必须重写hashCode()和equals()，但是一般情况下重写equals()方法时也要重写hashCode()方法。
  总结：

• hashCode主要用于提升查询效率提高哈希表性能，来确定在散列结构中对象的存储地址
• 重写equals()必须重写hashCode()
• 哈希存储结构中，添加元素重复性校验的标准就是先检查hashCode值，后判断equals()
• 两个对象equals()相等，hashcode()必定相等
• 两个对象hashcode()不等，equals()必定也不等
• 两个对象hashcode()相等，对象不一定相等，需要通过equals()进一步判断。