A brief discussion of equals and == in Java

When you first learn Java, you may often encounter the following code:

String str1 = new String("hello");
String str2 = new String("hello");
        
System.out.println(str1==str2);
System.out.println(str1.equals(str2));

Why are the output results of lines 4 and 5 different? What is the difference between == and equals methods? If you don't figure this out when you first learn Java, you will make some low-level errors when writing code in the future. Today let’s learn about the difference between == and equals methods.

1. What exactly does the relational operator "==" compare?

　The following sentence is an original quote from the book "Java Programming Thoughts":

　"Relational operators generate a boolean result, and they calculate the relationship between the values ​​of the operands."

This sentence seems simple, but it still needs to be understood carefully. To put it simply, == is used to compare whether values ​​are equal. Let’s take a look at a few examples:

public class Main {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
        int n=3;
        int m=3;
        
        System.out.println(n==m);
        
        String str = new String("hello");
        String str1 = new String("hello");
        String str2 = new String("hello");
        
        System.out.println(str1==str2);
        
        str1 = str;
        str2 = str;
        System.out.println(str1==str2);
    }

}

The output result is true false true

The result of n==m is true. This is easy to understand. The values ​​stored in variable n and variable m are both 3, which must be equal. And why are the results of the two comparisons of str1 and str2 different? To understand this, you only need to understand the difference between basic data type variables and non-basic data type variables.

　 There are 8 basic data types in Java:

Floating point type: float (4 byte), double (8 byte)

Integer type: byte (1 byte), short (2 byte), int (4 byte) , long(8 byte)

　Character type: char(2 byte)

　Boolean type: boolean (The JVM specification does not clearly stipulate the size of the space it occupies, but only stipulates that it can only take the literal values ​​"true" and "false" )

For the variables of these 8 basic data types, the variables directly store the "value", so when the relational operator == is used for comparison, the "value" itself is compared. It should be noted that floating point and integer types are both signed types, while char is an unsigned type (the value range of the char type is 0~2^16-1).

　That is to say, for example:

　int n= 3;

　int m=3;

　 Both variable n and variable m directly store the value "3", so when compared with ==, the result is true.

　For variables of non-basic data types, they are called reference type variables in some books. For example, str1 above is a reference type variable. A reference type variable stores not the "value" itself, but the address of its associated object in memory. For example, the following line of code:

　String str1;

　 This sentence declares a reference type variable, which is not associated with any object at this time.

　And use new String("hello") to generate an object (also called an instance of class String), and bind this object to str1:

　str1= new String("hello");

Then str1 points to an object (str1 is also called a reference to an object in many places). At this time, the variable str1 stores the storage address of the object it points to in memory, not the "value" itself, that is to say, it is not The string "hello" is stored directly. The references here are very similar to pointers in C/C++.

　So when you use == to compare str1 and str2 for the first time, the result is false. Therefore, they point to different objects respectively, which means that the memory addresses where they are actually stored are different.

In the second comparison, both str1 and str2 point to the object pointed to by str, so the result obtained is undoubtedly true.

2. What does equals compare to?

　The equals method is a method in the base class Object, so all classes that inherit from Object will have this method. In order to understand the role of the equals method more intuitively, let's look directly at the implementation of the equals method in the Object class.

　The source code path of this class is: Object.java under the java.lang path of src.zip in C:Program FilesJavajdk1.6.0_14 (depending on the personal jdk installation path).

The following is the implementation of the equals method in the Object class:

Obviously, in the Object class, the equals method is used to compare whether the references of two objects are equal, that is, whether they point to the same object.

But some friends may have questions again, why is the output result of the following piece of code true?

public class Main {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
        String str1 = new String("hello");
        String str2 = new String("hello");
        
        System.out.println(str1.equals(str2));
    }
}

To know what is going on, you can look at the specific implementation of the equals method of the String class. Also under this path, String.java is the implementation of the String class.

The following is the specific implementation of the equals method in the String class:

It can be seen that the String class has rewritten the equals method to compare whether the strings stored in the pointed string objects are equal.

　 Some other classes, such as Double, Date, Integer, etc., have overridden the equals method to compare whether the contents stored in the pointed objects are equal.

In summary:

　1) For ==, if it acts on a variable of a basic data type, it will directly compare whether its stored "value" is equal;

　　If it acts on a variable of a reference type, it will compare the address of the pointed object

2) For the equals method, note: the equals method cannot act on variables of basic data types

　　If the equals method is not overridden, the address of the object pointed to by the reference type variable is compared;

　such as String, Date If a class overrides the equals method, the contents of the pointed objects are compared.

For more articles related to equals and == in Java, please pay attention to the PHP Chinese website!