equals() method

equals(): 

The equals() method in Java is used to compare two objects for equality. 

It is defined in the Object class and can be overridden in custom classes to provide a specific implementation of object comparison.

The general syntax of the equals() method is:

public boolean equals(Object obj)

Here's an explanation of how the equals() method works:

Basic checks:

The method first checks if the object being compared is the same instance as the current object using the == operator.

 If they are the same instance, true is returned since an object is always equal to itself.

Next, it checks if the object being compared is null.

 If it is null, false is returned because a non-null object cannot be equal to null.

Type check:

The method checks if the object being compared is of the same class (or a subclass) as the current object.

 This is done using the getClass() method to get the runtime class of the object. 

If the classes are different, false is returned because objects of different classes are considered unequal.

Custom comparison:

After passing the basic checks, the method can perform custom comparison based on the specific equality criteria of the class.

The implementation can compare the fields or properties of the current object and the object being compared to determine if they are equal.

The comparison can be done using the equals() method of other objects or by directly comparing primitive types or reference types.

Return result:

If the objects pass all the checks and are considered equal according to the specific equality criteria of the class, the method returns true.

Otherwise, if any of the checks fail or the objects are deemed unequal, false is returned.

It's important to note that when overriding the equals() method, it is recommended to also override the hashCode() method to maintain the contract between the two methods. 

According to the contract, if two objects are considered equal according to equals(), their hash codes should be the same according to hashCode().

By providing a custom implementation of equals(), you can define the criteria for equality between objects of your class, allowing for more meaningful object comparison and utilization in Java applications.

Here's an example that demonstrates the implementation of the equals() method in a custom class:

public class Point {
private int x; 
private int y; 
public Point(int x, int y) { 
this.x = x;
        this.y = y; 
 } 
// Getters and setters

    @Override 
public boolean equals(Object obj) {
if (this == obj) {
return true;
 } 
if (obj == null || getClass() != obj.getClass()) { 
return false; 
 }
Point otherPoint = (Point) obj; 
return x == otherPoint.x && y == otherPoint.y; 
 }
 }

In the above example, we have a Point class that represents a 2D point with x and y coordinates . 

We override the equals() method to define the equality criteria for instances of the Point class.

In the equals() method, we first perform some basic checks:

If the objects being compared are the same instance (using the == operator), we return true since an object is always equal to itself.

If the object being compared is null or of a different class than Point, we return false.

Then, we cast the obj parameter to a Point object and compare the x and y fields of the current instance and the other instance using the == operator.

If the x and y values of both points are equal, we consider the two Point objects equal and return true. Otherwise, we consider them unequal and return false.

By overriding the equals() method, we can define the criteria for equality between Point objects. In this example, two Point objects are considered equal if their x and y coordinates are the same.

equals() method in Collection:

In collections such as List, Set, and Map, the equals() method is used to determine equality between objects.

It plays a crucial role in these collections for various operations, including searching, removing, and determining uniqueness.

Let's consider a few specific collection scenarios:

List:

When using the contains() method on a List, it internally calls the equals() method of each element in the list to check for equality.

Similarly, the indexOf() and lastIndexOf() methods also rely on the equals() method to find the index of an element in the list.

When removing elements using the remove() method, the equals() method is used to determine which element(s) to remove.

Set:

In a Set, the equals() method is crucial to check if an element already exists in the set before adding it.

The add() method internally uses the equals() method to ensure uniqueness of elements.

The contains() method in a Set also relies on the equals() method to check if an element is present in the set.

Similarly, the remove() method in a Set uses the equals() method to identify the element to be removed.

Map:

In a Map, the equals() method is used to determine if a key already exists in the map when using methods like containsKey() and get().

When using the remove() method with a specific key, the equals() method is used to locate the correct entry to remove.

Additionally, when using a custom class as a key in a Map, it's important to correctly implement the equals() and hashCode() methods to ensure proper key lookup and retrieval.

In all these collection scenarios, the equals() method is called to compare objects for equality, allowing the collections to perform operations based on the comparison results.

It's crucial to ensure that the equals() method is correctly implemented in the classes whose objects will be used in collections to guarantee the expected behavior.

Remember that when overriding the equals() method in your custom class, you should also override the hashCode() method to maintain the contract between the two methods.

This ensures proper functioning of collections that rely on both equality and hashing mechanisms, such as HashSet and HashMap.

subString() In String

indexOf() In String