The difference between equals and = = in Java



The data types in Java can be grouped into two categories:
1. The basic data type, also known as the original data type. Byte,short,char,int,long,float,double,boolean
The comparison between them applies the double equals sign (= =) and compares them to their values.
2. Composite data type (Class)
When they compare with (= =), they compare their store address in memory, so unless the same object is new, their comparison results to true, otherwise the result is false. All classes in Java are inherited from the base class of object, and a method of equals is defined in the base class in object, and the initial behavior of this method is to compare the memory address of the object, but in some class libraries This method is overwritten, such as String,integer, Date in these classes equals has its own implementation, and is no longer the address of the comparison class in heap memory.
For equals comparisons between composite data types, the comparison between them is based on the address value of their place in memory, without having to overwrite the Equals method, because the Equals method of the object is also compared with the double equal sign (= =). So the result of the comparison is the same as the result of the double equal sign (= =).

1 public class TestString {2 public static void Main (string[] args) {3 String S1 = "Monday"; 4 String s2 = "Monday"; 5 if (S1 = = s2) 6 {7 System.out.println ("S1 = = s2"); 8 Else {9 System.out.println ("S1!= S2");} 10} 11} Compile and run the program, output: S1 = = S2 Description: S1 and S2 refer to the same String object-"Monday"!
2. A few more changes to the program, there will be more strange discovery:

public class TestString {public static void main (string[] args) {String S1 = "Monday"; String s2 = new String ("Monday"); if (S1 = = s2) {System.out.println ("S1 = = s2"); else {System.out.println ("S1!= S2");} if (s1.equals (S2)) {System.out.println ("S1 equals S2");} else {System.out.println ("S1 not equals S2");}}
We'll create the S2 with the new operator.
Program output:
S1!= S2
S1 equals s2
Description: S1 S2 refers to two "Monday" string objects, respectively

3. String buffer pool
Originally, the program will create a string buffer pool when it is run when using S2 = "Monday" When the expression is to create a string, the program first looks for objects of the same value in this string buffer pool, and in the first program, S1 is first placed in the pool, so when the S2 is created, The program found a S1 with the same value
Refer S2 to the object referenced by S1 "Monday"
In the second procedure, using the new operator, he understood the telling program: "I want a new one." Don't be old. "So a new" Monday "Sting object is created in memory. Their values are the same, but the positions are different, one swims in the pool and a rest on the shore. Alas, it is a waste of resources, obviously the same must be done separately.

4. Change the procedure again:

public class TestString {public static void main (string[] args) {String S1 = "Monday"; String s2 = new String ("Monday"); S2 = S2.intern (); if (S1 = = s2) {System.out.println ("S1 = = s2"); else {System.out.println ("S1!= S2");} if (s1.equals (S2)) {System.out.println ("S1 equals S2");} else {System.out.println ("S1 not equals S2");}}
This time add: S2 = S2.intern ();
Program output:
S1 = = S2
S1 equals s2
Originally, (Java.lang.String's Intern () method, the return value of the "ABC". Intern () method, or the string "abc", looks like this method is useless. But in fact, it does a little trick: Check the string pool for "abc" such a string, if it exists, return the string in the pool, if not, the method will add "ABC" to the string pool, and then return its reference.
）