{"id":2199,"date":"2024-02-25T02:24:21","date_gmt":"2024-02-25T02:24:21","guid":{"rendered":"https:\/\/datmt.com\/?p=2199"},"modified":"2024-02-25T02:24:22","modified_gmt":"2024-02-25T02:24:22","slug":"understanding-and-equals-in-java","status":"publish","type":"post","link":"https:\/\/datmt.com\/backend\/java\/understanding-and-equals-in-java\/","title":{"rendered":"Understanding == and equals() in Java"},"content":{"rendered":"\n

Overview<\/h2>\n\n\n\n

In Java, the\u00a0==<\/code>\u00a0operator and the\u00a0equals()<\/code>\u00a0method are both used to compare objects, but they serve different purposes and operate in fundamentally different ways.<\/p>\n\n\n\n

Stack, Heap, and References<\/h2>\n\n\n\n

Before delving into the differences between == and equals, first, you need to understand what are references and how they are stored and used in Java. <\/p>\n\n\n\n

References and the Heap<\/h3>\n\n\n\n

In Java, objects are stored in the heap memory. The heap is a runtime data area from which memory for all class instances and arrays is allocated. It is created at the JVM start-up. <\/p>\n\n\n\n

Heap memory for objects is reclaimed by an automatic memory management system known as garbage collection, which frees memory that is no longer reachable by any references. <\/p>\n\n\n\n

When a new object is created, for example,\u00a0Object a = new Object()<\/code>, the actual object is placed in the heap, and the variable\u00a0a<\/code>\u00a0stores a reference to it. This reference is essentially the memory address where the object is stored in the heap. However, the variable\u00a0a<\/code>\u00a0itself is stored in the stack memory.<\/p>\n\n\n\n

Stack Memory and References<\/h3>\n\n\n\n

Stack memory is used for execution threads and stores primitive variables and references to objects in the heap space. Each thread in a Java application has its own stack that is created when the thread is created. The stack contains frames that hold local variables and references to other objects in the heap. <\/p>\n\n\n\n

When a method is called, a new frame is pushed onto the stack for that method’s local variables and references. When the method completes, the frame is popped off the stack. The references stored in the stack memory point to objects in the heap. These references are critical for accessing and manipulating the objects. For instance, when you pass an object to a method, what is passed is the reference to the object. This allows methods to operate on the same object instances stored in the heap.<\/p>\n\n\n\n

The == Operator<\/h2>\n\n\n\n

The\u00a0==<\/code>\u00a0operator is used for reference comparison, which means it checks if two object references point to the same memory location. When you use\u00a0==<\/code>\u00a0with object references, it will return\u00a0true<\/code>\u00a0if both references are pointing to the same object instance in the heap, otherwise, it will return\u00a0false<\/code>.<\/p>\n\n\n\n

String s1 = "HELLO";\nString s2 = "HELLO";\nString s3 = new String("HELLO");\n\nSystem.out.println(s1 == s2); \/\/ true, because s1 and s2 refer to the same instance in the string constant pool\nSystem.out.println(s1 == s3); \/\/ false, because s3 is created in the heap as a new instance<\/pre><\/div>\n\n\n\n
In the above example,\u00a0s1<\/code>\u00a0and\u00a0s2<\/code>\u00a0point to the same string literal in the string constant pool, hence\u00a0s1 == s2<\/code>\u00a0evaluates to\u00a0true<\/code>. However,\u00a0s3<\/code>\u00a0is created with the\u00a0new<\/code>\u00a0keyword, which forces the creation of a new string object in the heap, so\u00a0s1 == s3<\/code>\u00a0evaluates to\u00a0false<\/code>.<\/p>\n\n\n\n
The equals() Method<\/h2>\n\n\n\n
The\u00a0equals()<\/code>\u00a0method, on the other hand, is intended for content comparison. It checks if two objects are “equal” in terms of their state (the data they hold), not their reference. The behavior of the\u00a0equals()<\/code>\u00a0method is not defined by the language itself but by the specific implementation within the classes. <\/p>\n\n\n\n
By default, the\u00a0equals()<\/code>\u00a0method in the\u00a0Object<\/code>\u00a0class compares the references, just like the\u00a0==<\/code>\u00a0operator. However, many classes override the\u00a0equals()<\/code>\u00a0method to provide a more meaningful comparison based on the content of the objects.For example, the\u00a0String<\/code>\u00a0class overrides the\u00a0equals()<\/code>\u00a0method to compare the sequence of characters within the two string objects:<\/p>\n\n\n\n
String s1 = new String("HELLO");\nString s2 = new String("HELLO");\n\nSystem.out.println(s1.equals(s2)); \/\/ true, because the content of both strings is the same<\/pre><\/div>\n\n\n\n
Even though\u00a0s1<\/code>\u00a0and\u00a0s2<\/code>\u00a0refer to different objects,\u00a0s1.equals(s2)<\/code>\u00a0returns\u00a0true<\/code>\u00a0because the content of both strings is identical.<\/p>\n\n\n\n
Key Differences<\/h2>\n\n\n\n