equals() in Java

After several days of study, I finally have a more comprehensive understanding of the usage of equals and make a summary.

1. The original meaning of equals - that is, what is the meaning of the equals() method defined in the Object object.

(The function of == is attached here first, and there will be a description later. Because the relationship between == and the equals() method is very close, I will have my own opinions later.

== is used to compare references and comparisons Basic data types have different functions:
Comparing basic data types, if the two values ​​are the same, the result is true
And when comparing references, if the reference points to the same object in memory, the result is true)

public boolean equals(Object obj)

The comparison rule is: when the object referenced by parameter obj is the same object as the current object, it returns true, otherwise it returns false.

public class Fish {
private int weight;
private String color;

public Fish(int weight, String color) {
this.color = color;
this.weight = weight;
}

public int getWeight() {
return weight;
}

public void setWeight(int weight) {
This.weight = weight;
}

public String getColor() {
return color;
}

public void setColor(String color) {
this.color = color ;
}

}

public class EqualsTest {
public static void main(String[] args) {
Fish f1 = new Fish(1, "blue");
Fish f2 = new Fish(1, "blue");

        System.out.println(f1 == f2);
    System.out.println(f1.equals(f2));
  }
}

——————The running result is—————— —

false
false

It can be seen that the original intention of the equals() method is to determine whether the references of two objects are the same.

2. There are some classes in the JDK class that cover the equals() method of the object class. The comparison rule is: if the two objects have the same type and the same content, true will be returned. These classes are:
java.io. file,java.util.Date,java.lang.string, wrapper class (Integer, Double, etc.)

public class EqualsTest {
public static void main(String[] args) {
String s1=new String("sss" ); T String S2 = New String ("SSS");

System.out.println (s1 == S2);
System.out.println (s1.equals (s2)); ————————The operation result is——————

false
true

From this we know that the equals() method in String has been overwritten, so that its meaning becomes the comparison of the contents of two objects. Is it consistent

3. If we want to override the equals() method ourselves, let it compare the content or have other methods of use (of course we usually use it to compare the content, but what is the real implementation of the overridden method? Yes, who knows? O(∩_∩)O~)

public class Fish {

private int weight;

private String color;

    public Fish(int weight, String color) {
        this.color = color;
        this.weight = weight;
    }
    
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((color == null) ? 0 : color.hashCode());
        result = prime * result + weight;
        return result;
    }
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Fish other = (Fish) obj;
        if (color == null) {
            if (other.color != null)
                return false;
        } else if (!color.equals(other.color))
            return false;
        if (weight != other.weight)
            return false;
        return true;
    }
    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

}

public class EqualsTest {
    public static void main(String[] args) {
        Fish f1 = new Fish(1, "blue");
        Fish f2 = new Fish(1, "blue");

 

        System.out.println(f1 == f2);
        System.out.println(f1.equals(f2));
    }
}

——————运行结果为——————

false
true

此例子中我复写了equals()方法和hashcode()方法，使得equals()方法脱离的本意，不再是比较两个对象的引用是否相同，而是比较其内容是否相同。

以上内容为一般书上的总结，下面是我自己想到的一些东西。

我们可以知道计算机归根到底进行的只是一些二进制数的与或非运算，加法乘法运算。由此有了些基本的运算符，所有的函数本质上其实现都是使用基本运算符来实现的。而==是基本运算符中的一个，它的作用：用于比较引用和比较基本数据类型时具有不同的功能：
     比较基本数据类型，如果两个值相同，则结果为true
     而在比较引用时，如果引用指向内存中的同一对象，结果为true

而equals()作为方法，我们可以推测知道，它其中的实现所使用的肯定是==运算符。再进一步的思考，equals()本意不正是==运算符进行对象比较时候的作用吗。那么，既然是两者有同样的作用，为什么还要弄出一个equals()方法来呢。因为==运算符不允许我们进行覆盖，也就是说它限制了我们的表达。在上面的第三个例子中，我们复写equals()方法，达到比较对象内容是否相同的目的。而这些通过==运算符是做不到的。

更多Java中的equals()相关文章请关注PHP中文网！