Technical Blog

Topic 8 Java

What happens if we do not override the equals() method and the hashCode() method in Java? How does it affect the behavior of collections like HashSet or HashMap? Provide an explanation with code examples.

equals() Method:

By default, the equals() method in Java, inherited from Object, checks for reference equality (whether two objects point to the same memory location). If not overridden, even if two objects have identical properties, they will not be considered equal unless they refer to the same memory location.

hashCode() Method:

By default, the hashCode() method generates a hash code based on the memory address of the object. If not overridden, objects with identical properties may generate different hash codes, affecting their behavior in hash-based collections (like HashSet, HashMap)

class Person {
String name;
int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class Main {
public static void main(String[] args) {
Person p1 = new Person("Alice", 30);
Person p2 = new Person("Alice", 30);

        System.out.println("p1.equals(p2): " + p1.equals(p2)); // Reference equality

        HashSet<Person> set = new HashSet<>();
        set.add(p1);
        set.add(p2);

        System.out.println("Set size: " + set.size()); // Unexpected behavior
    }
}

The output.

p1.equals(p2): false
Set size: 2

Since equals() is not overridden, the two Person objects are not considered equal, even though they have identical properties.
The hashCode() method is also not overridden, so the two objects have different hash codes, leading to both being stored in the HashSet

Only doing the equal method.

import java.util.HashSet;

class Person {
    String name;
    int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Person person = (Person) obj;
        return age == person.age && name.equals(person.name);
    }
}

public class Main {
    public static void main(String[] args) {
        Person p1 = new Person("Alice", 30);
        Person p2 = new Person("Alice", 30);

        HashSet<Person> set = new HashSet<>();
        set.add(p1);
        set.add(p2);

        System.out.println("Set size: " + set.size()); // Still unexpected behavior
    }
}

Set size is 2.

Even though equals() is overridden, the default hashCode() still generates different hash codes for p1 and p2. Therefore, both objects are stored in the HashSet.

Overridding both the equal and hashCode().

import java.util.HashSet;
import java.util.Objects;

class Person {
    String name;
    int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Person person = (Person) obj;
        return age == person.age && name.equals(person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

public class Main {
    public static void main(String[] args) {
        Person p1 = new Person("Alice", 30);
        Person p2 = new Person("Alice", 30);

        HashSet<Person> set = new HashSet<>();
        set.add(p1);
        set.add(p2);

        System.out.println("Set size: " + set.size()); // Correct behavior
    }
}

When two object are equal() then the hashCode() should also be equal. When two hashCode is equal then the object may not be equal.

Why do we need Spring Boot.

Spring Boot is used to make Spring application development faster, more consistent, and production-ready.

  1. Faster bootstrap Auto-configuration reduces manual setup for common concerns such as web, data source, JPA, security, and messaging.

  2. Less boilerplate It follows convention over configuration, so developers spend less time wiring infrastructure and more time writing business logic.

  3. Standalone deployment Embedded servers such as Tomcat, Jetty, or Undertow allow the application to run as a self-contained service without managing a separate application server.

  4. Dependency simplification Starter dependencies such as spring-boot-starter-web and spring-boot-starter-data-jpa provide opinionated, compatible dependency sets.

  5. Production readiness Actuator adds health checks, metrics, monitoring endpoints, and operational visibility, which are essential in real systems.

  6. Microservice friendliness It works well with externalized configuration, containerized deployment, and Spring Cloud patterns such as config management, service discovery, and resilience.

  7. Strong ecosystem alignment It integrates cleanly with Spring Security, Spring Data, Spring Batch, Kafka, Redis, and other enterprise components.

In short, Spring Boot removes setup friction, standardizes application structure, and gives teams a faster path from development to production.

Why we need Spring Boot when Spring.

Spring Boot is essentially an extension of the Spring Framework, designed to simplify the development process and reduce the complexity of configuring and deploying Spring-based applications. Here’s a comparison of why Spring Boot is often preferred over Spring (without Spring Boot), highlighting its advantages:

  1. Ease of Setup and Configuration Spring requires a lot of manual configuration. You need to configure XML files (or annotations) for beans, dependency injection, web servers, data sources, etc. This can be tedious and error-prone. Spring Boot provides auto-configuration, meaning that it automatically configures your application based on the libraries in your project and other settings. For instance, if you’re using a database, Spring Boot will auto-configure the necessary beans for the DataSource, EntityManagerFactory, etc. Spring: More configuration required (XML or annotations). Spring Boot: Much less configuration; auto-configuration handles most of it.

  2. Embedded Web Server Spring does not include an embedded web server out-of-the-box. You would need to configure and deploy your application on an external server (like Tomcat or Jetty). Spring Boot includes embedded servers like Tomcat, Jetty, or Undertow, which means you can run your application as a standalone Java application with an embedded server. No need for a separate server setup or deployment. Spring: External server setup is required. Spring Boot: Standalone application with an embedded server.

  3. Project Setup and Structure Spring involves a lot of manual setup when creating a new project, often requiring the creation of complex configuration files, class structures, and more. Spring Boot offers Spring Initializr, which is an online tool (or integrated in IDEs like IntelliJ IDEA and Eclipse) that quickly generates a Spring Boot project with the necessary dependencies and structure, making it easier to start development. Spring: Manually create project and structure. Spring Boot: Quick project setup using Spring Initializr.

  4. Production-Ready Features Spring does not come with built-in support for monitoring, metrics, or other production-ready features. Spring Boot includes features like Spring Boot Actuator, which provides production-ready endpoints for monitoring and managing your application (e.g., health checks, metrics, environment details, etc.). Spring: Production features need to be added manually. Spring Boot: Built-in production-ready features with minimal configuration.

  5. Dependency Management Spring requires you to manually manage dependencies, and you might need to include specific versions of libraries to ensure compatibility. Spring Boot comes with dependency management that includes a set of “starter dependencies” which bundle commonly used libraries. For instance, the spring-boot-starter-web dependency includes libraries for creating a web application, such as Spring MVC and embedded Tomcat. Spring: Manually manage dependencies. Spring Boot: Starter dependencies simplify the process.

  6. Microservices Architecture Spring can be used for microservices, but it doesn’t offer tools for building and managing microservices efficiently. Spring Boot is designed with microservices in mind, especially when integrated with Spring Cloud. It provides tools for building scalable and resilient microservices, like service discovery, distributed configuration, and circuit breakers. Spring: Not specifically optimized for microservices. Spring Boot: Built with microservices in mind, integrates well with Spring Cloud.

  7. Faster Development and Faster Boot Times Spring applications can have longer startup times due to the extensive configuration and setup. Spring Boot has optimized startup times, thanks to its auto-configuration and pre-configured libraries. Spring: Can have slower startup due to manual configurations. Spring Boot: Faster development cycle and boot time with minimal configuration.

  8. Less Boilerplate Code Spring requires writing a lot of boilerplate code for configuration and setup. Spring Boot uses convention over configuration to reduce the amount of code you need to write. It minimizes the need for XML or Java-based configurations, simplifying your development process. Spring: Requires more boilerplate configuration code. Spring Boot: Reduced boilerplate, leveraging auto-configuration.