Java Records: A Modern Way to Write Immutable Data Classes

In the evolving world of Java, managing data efficiently and ensuring immutability are key concerns for developers. and to solve this problem Java Introduced records. A Java records offer a modern approach to creating immutable data classes.

Unlike traditional Java classes, records are designed specifically for holding data, reducing boilerplate code and enhancing readability. And in this blog we dives into Java records, their benefits, and how they revolutionize the creation of immutable data structures.

What Are Java Records?

A record is a special type of class in Java that automatically provides a concise syntax for declaring immutable data carriers. It generates constructors, getters, equals(), hashCode(), and toString() methods based on the components defined in its declaration. This eliminates the need to write repetitive code for simple data-holding classes.

Syntax Example

public record Person(String name, int age) {}

This single line creates a Person record with name and age as components, automatically providing:

A canonical constructor.
Getter methods (name() and age()).
Implementations of equals(), hashCode(), and toString().

Why Use Records?

Immutability: Records are inherently immutable, ensuring data cannot be altered after creation, which is ideal for value-based objects.
Reduced Boilerplate: No need to manually write getters, setters, or equality methods.
Clarity: The intent of the class as a data holder is immediately clear, improving code maintainability.
Performance: Compiled records are optimized for memory and speed compared to traditional classes with similar functionality.

Key Features

Compact Constructors: Allows validation or initialization logic within a concise constructor.

public record Person(String name, int age) {
    public Person {
        if (age < 0) throw new IllegalArgumentException("Age cannot be negative");
        if (name == null || name.isBlank()) throw new IllegalArgumentException("Name cannot be empty");
    }
}

Component Access: Access components using method names that match the field names (e.g., person.name()).
No Setter Methods: Prevents modification, enforcing immutability.
Custom Methods: You can add business logic or additional methods as needed.

public record Person(String name, int age) {
    public boolean isAdult() {
        return age >= 18;
    }
}

Creating and Using Records

Instantiation

Person person = new Person("Alice", 25);
System.out.println(person); // Output: Person[name=Alice, age=25]
System.out.println(person.isAdult()); // Output: true

Immutability in Action

Once created, the record's state cannot change:

person.name("Bob"); // Compilation error: no setter exists

Comparing with Traditional Classes

Traditional immutable classes require more code:

public class PersonOld {
    private final String name;
    private final int age;

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

    public String getName() { return name; }
    public int getAge() { return age; }

    @Override public boolean equals(Object o) { ... }
    @Override public int hashCode() { ... }
    @Override public String toString() { ... }
}