Why Use Records?#

Before records, developers had to manually define fields, constructors, getters, and often override methods like equals(), hashCode(), and toString() for simple data classes. This was time-consuming and error-prone, especially for data-centric classes where the main concern is holding and manipulating data.

Syntax#

Here’s a simple record declaration:

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

This is equivalent to the following traditional Java class:

1
public class Person {
2
    private final String name;
3
    private final int age;
4

5
    public Person(String name, int age) {
6
        this.name = name;
7
        this.age = age;
8
    }
9

10
    public String getName() {
11
        return name;
12
    }
13

14
    public int getAge() {
15
        return age;
16
    }
17

18
    @Override
19
    public boolean equals(Object o) {
20
        if (this == o) return true;
21
        if (o == null || getClass() != o.getClass()) return false;
22
        Person person = (Person) o;
23
        return age == person.age && name.equals(person.name);
24
    }
25

26
    @Override
27
    public int hashCode() {
28
        return Objects.hash(name, age);
29
    }
30

31
    @Override
32
    public String toString() {
33
        return "Person{name='" + name + "', age=" + age + "}";
34
    }
35
}

As you can see, the record class dramatically reduces boilerplate code, automatically generating:

• A constructor,
• Getter methods (e.g., name() and age()),
• equals(), hashCode(), and toString().

Example with Lombok#

Before the introduction of record, Lombok was a popular way to avoid boilerplate. Lombok provides annotations like @Data and @AllArgsConstructor to generate similar code automatically.

Here’s an example using Lombok:

1
import lombok.AllArgsConstructor;
2
import lombok.Data;
3

4
@Data
5
@AllArgsConstructor
6
public class Person {
7
    private final String name;
8
    private final int age;
9
}

While Lombok reduces boilerplate, it requires adding external dependencies and annotations to achieve similar results. With record, Java natively supports immutability and concise syntax, making it a more natural fit for modern Java applications.

Advantages of Records over Lombok and Other Approaches#

• Native Support: Records are built into Java, requiring no external dependencies.
• Concise Syntax: Records are more succinct, reducing code to just the essentials.
• Immutability: Records enforce immutability by default, enhancing data safety.
• Cleaner Code: No need for annotations or external libraries like Lombok for basic data structures.

Custom Constructors and Methods#

While records provide a default constructor and methods, you can define custom behavior when necessary.

1
public record Person(String name, int age) {
2
    public Person {
3
        if (age < 0) {
4
            throw new IllegalArgumentException("Age cannot be negative");
5
        }
6
    }
7
}

1
public record Person(String name, int age) {
2
    public String greeting() {
3
        return "Hello, my name is " + name;
4
    }
5
}

Example of Record with Interface#

Records can implement interfaces, which allows for more flexible data classes:

1
public record Rectangle(double length, double width) implements Shape {
2
    @Override
3
    public double area() {
4
        return length * width;
5
    }
6
}

Limitations of Records#

• No Inheritance: Records cannot extend other classes.
• No Setters: Fields in records are final, enforcing immutability.
• Concrete Class: Records cannot be abstract.

Conclusion#

Java record classes provide a clean, concise, and efficient way to define immutable data classes with minimal boilerplate code. For simple data holders, records offer a better alternative to traditional classes and even tools like Lombok by leveraging native Java features. They simplify the development process, ensuring immutability, providing automatic method generation, and helping developers focus on functionality rather than repetitive code.

Records are the future of immutable data structures in Java, offering a more efficient and readable way to work with data-centric objects.

Ref:

• Baeldung java-record-keyword