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 simplifies the development of Java applications, particularly for building microservices. Below are the key reasons why Spring Boot is beneficial:

  1. Reduced Complexity Auto-configuration: Spring Boot automatically configures application components based on the dependencies in your classpath. For instance, if you’re using a database, Spring Boot automatically configures DataSource, Hibernate, and the necessary configurations. Embedded Servers: You don’t need to configure a separate web server (like Tomcat or Jetty) since Spring Boot includes embedded servers, simplifying the deployment process.
  2. Quick Setup and Development Minimal Configuration: It eliminates the need for boilerplate configuration files (like web.xml in traditional Spring applications). With Spring Boot, you can get started with minimal setup, especially with @SpringBootApplication as the main entry point. Starter Projects: Spring Boot offers a set of starter templates (e.g., spring-boot-starter-web, spring-boot-starter-data-jpa), which include common dependencies and configurations for specific tasks.
  3. Microservices Ready Spring Cloud Integration: Spring Boot seamlessly integrates with Spring Cloud for building scalable and robust microservices. You can easily implement service discovery, centralized configuration, messaging, and more. Production-Ready Features: It provides tools for metrics, health checks, and externalized configuration which are essential for running applications in production environments.
  4. Minimal Boilerplate Code Convention over Configuration: Spring Boot follows the principle of convention over configuration, meaning that it reduces the need to write verbose configurations, focusing instead on just writing the application code. Component Scanning: With Spring Boot, all the Spring components are automatically scanned, and you don’t need to explicitly configure every bean or dependency.
  5. Seamless Integration with Other Tools Spring Boot Actuator: Provides production-ready features like health checks, metrics, and application insights. Spring Boot DevTools: Improves development time by providing features like automatic restarts and live reload.
  6. Ecosystem Integration Spring Ecosystem: Spring Boot integrates well with other Spring projects like Spring Security, Spring Data, Spring Batch, etc., allowing for scalable and secure enterprise-level applications.

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.