Java Records

Learning Objectives

After completing this lesson, you will be able to:

• Understand what Records are
• Learn why Records were introduced
• Compare Records with traditional POJOs
• Create immutable data classes using Records
• Use Constructors in Records
• Add Methods to Records
• Use Compact Constructors
• Understand Record Internals
• Use Records with Collections and Streams
• Use Records in Spring Boot Applications
• Learn Best Practices
• Prepare for Java Interview Questions

Introduction

One of the biggest problems in Java before Java 16 was writing boilerplate code.

Consider a simple Employee class.

public class Employee {

    private final int id;

    private final String name;

    private final double salary;

    public Employee(int id,
                    String name,
                    double salary){

        this.id = id;
        this.name = name;
        this.salary = salary;

    }

    public int getId(){

        return id;

    }

    public String getName(){

        return name;

    }

    public double getSalary(){

        return salary;

    }

    @Override
    public boolean equals(Object obj){

        ...

    }

    @Override
    public int hashCode(){

        ...

    }

    @Override
    public String toString(){

        ...

    }

}

Almost 80% of the code is boilerplate.

Java 16 introduced Records to solve this problem.

A Record automatically generates:

• Constructor
• Getters (Accessor Methods)
• equals()
• hashCode()
• toString()

Records are ideal for immutable data carriers such as DTOs, API responses, configuration objects, and value objects.

Why Records?

Without Records

public class User {

    private final String username;

    private final String email;

    // Constructor

    // Getters

    // equals()

    // hashCode()

    // toString()

}

With Records

public record User(

    String username,

    String email

){ }

That's all.

Benefits

• Less Code
• Immutable
• Thread Safe
• Better Readability
• Cleaner APIs

What is a Record?

A Record is a special kind of class designed to model immutable data.

Syntax

public record Employee(

    int id,

    String name,

    double salary

){

}

Creating Record Objects

Employee employee =

new Employee(

101,

"Rahul",

75000

);

System.out.println(employee);

Output

Employee[id=101,
name=Rahul,
salary=75000.0]

Accessor Methods

Records automatically generate accessor methods.

Employee employee =

new Employee(

101,

"John",

90000

);

System.out.println(

employee.id()

);

System.out.println(

employee.name()

);

System.out.println(

employee.salary()

);

Output

101

John

90000.0

Notice:

Accessor methods are:

employee.id()

NOT

employee.getId()

Auto Generated Methods

Java automatically generates

• Constructor
• Accessor Methods
• equals()
• hashCode()
• toString()

Equivalent Class

Employee Record

↓

Compiler

↓

Immutable Java Class

equals()

Employee e1 =

new Employee(

1,

"Amit",

50000

);

Employee e2 =

new Employee(

1,

"Amit",

50000

);

System.out.println(

e1.equals(e2)

);

Output

true

hashCode()

Automatically generated.

System.out.println(

employee.hashCode()

);

toString()

Automatically generated.

System.out.println(

employee

);

Output

Employee[id=101,
name=Amit,
salary=50000]

Custom Constructor

Records support constructors.

public record Employee(

int id,

String name){

    public Employee(

        int id,

        String name){

        this.id = id;

        this.name = name;

    }

}

Compact Constructor

Preferred approach.

public record Employee(

int id,

String name){

    public Employee{

        if(id <= 0){

            throw new IllegalArgumentException(

            "Invalid ID"

            );

        }

    }

}

The compiler automatically assigns fields after validation.

Adding Methods

Records can contain methods.

public record Employee(

int id,

String name){

    public String greeting(){

        return "Welcome " + name;

    }

}

Usage

System.out.println(

employee.greeting()

);

Static Members

Records support static fields and methods.

public record User(

String username){

    public static String company(){

        return "TechLearningPro";

    }

}

Nested Records

public class Company{

    public record Employee(

    int id,

    String name){

    }

}

Record with Collections

public record Department(

String name,

List<Employee> employees){

}

For deep immutability, use immutable collection implementations or defensive copies.

Records with Streams

employees.stream()

.filter(

e -> e.salary() > 80000

)

.forEach(System.out::println);

Record Internals

Compiler

public record Employee(

int id,

String name){

}

Conceptually becomes

final class Employee

extends Record

Properties

• Final Class
• Final Fields
• Immutable
• Cannot Extend Another Class

Record Memory Diagram

               JVM Heap
                   │
          Employee Record
          ┌──────────────┐
          │ id = 101     │
          │ name = Rahul │
          └──────────────┘

Record Restrictions

Records can:

• Implement interfaces
• Have methods
• Have constructors
• Have static members

Records cannot:

• Extend another class
• Declare mutable instance fields
• Add extra instance variables outside the record components

Record vs POJO

Real-World Example: API Response

public record ApiResponse(

int status,

String message){

}

Real-World Example: Spring Boot DTO

public record EmployeeDTO(

Long id,

String name,

String department){

}

Spring Boot 3 fully supports Records for request and response DTOs.

Real-World Example: Configuration

public record DatabaseConfig(

String url,

String username,

String password){

}

Best Practices

Use Records for DTOs

Ideal for:

• REST Responses
• Request Objects
• Events
• Configuration
• Value Objects

Keep Records Immutable

Avoid mutable objects inside records when possible.

Use Compact Constructors

Validate inputs without repeating assignments.

Prefer Records for Read-Only Data

If objects should not change after creation, Records are an excellent choice.

Use with Streams

Records integrate naturally with Streams and functional programming.

Common Mistakes

Trying to Modify Fields

Wrong

employee.name = "Rahul";

Records are immutable.

Using Getters

Wrong

employee.getName();

Correct

employee.name();

Extending a Record

Wrong

class Manager extends Employee

Records are implicitly final.

Using Records for JPA Entities

Avoid using Records as JPA entities because most JPA providers require mutable entities, a no-argument constructor, and proxy support.

Use Records for DTOs instead.

Assuming Deep Immutability

A record's fields are final, but if a field references a mutable object (for example, a List), the contents can still change unless you create immutable copies.

Hands-on Exercise

Create a Java program that:

1. Creates a Student record.
2. Creates an EmployeeDTO record.
3. Uses accessor methods.
4. Demonstrates equals().
5. Demonstrates hashCode().
6. Creates a compact constructor for validation.
7. Adds a custom method.
8. Uses records with Streams.
9. Uses records inside a Spring Boot REST response.
10. Demonstrates nested records.

Summary

Records, introduced in Java 16, provide a concise and immutable way to model data. They eliminate boilerplate by automatically generating constructors, accessors, equals(), hashCode(), and toString(). Records are ideal for DTOs, API models, configuration objects, and value objects, and they integrate seamlessly with Streams, Lambdas, and Spring Boot. They are not intended to replace every class but are an excellent choice for immutable data carriers.

Key Takeaways

• Records are immutable data carriers.
• Records dramatically reduce boilerplate code.
• The compiler generates constructors, accessors, equals(), hashCode(), and toString().
• Accessor methods use the component name (for example, name()), not JavaBean getters.
• Compact constructors are ideal for validation.
• Records can implement interfaces but cannot extend classes.
• Records are implicitly final.
• Prefer Records for DTOs and API models.
• Avoid using Records as JPA entities.
• Records work well with Streams, Lambdas, and modern Spring Boot applications.

Professional Interview Questions