Java Record: A New Way to Create Data Classes

Learn how to use Java Record, a new feature that allows you to create immutable data classes with minimal syntax and maximum functionality. Find out how to declare, customize, and use records.

What is a Java Record?

Java is a popular and widely used programming language that is constantly evolving and adding new features. One of the latest features that was introduced in Java 14 as a preview feature, and extended in Java 15, is Java Record. Record is a special kind of class that is designed to hold immutable data concisely and conveniently. Records can reduce the boilerplate code that is typically required for creating data carrier classes, such as POJOs (Plain Old Java Objects) and DTOs (Data Transfer Objects).

What is the problem that records solve?

As developers and software engineers, we aim to always design ways to obtain maximum efficiency and if we need to write less code for it, then that’s a blessing. In Java, a record is a special type of class declaration aimed at reducing the boilerplate code. Java records were introduced to be used as a fast way to create data carrier classes, i.e. the classes whose objective is to simply contain data and carry it between modules, also known as POJOs (Plain Old Java Objects) and DTOs (Data Transfer Objects).

To illustrate the problem that records solve, let us consider a simple class Employee, whose objective is to contain an employee’s data such as its ID, name, and address, and act as a data carrier to be transferred across modules. To create such a simple class, you’d need to define its constructor, getter, and setter methods, and if you want to use the object with data structures like HashMap or print the contents of its objects as a string, we would need to override methods such as equals (), hashCode (), and toString (). For example, we can create a simple Employee data class with id, name and an address:

public class Employee {
    private final String name;
    private final String address;
    private final int id;

    public Employee(String name, String address, int id) {
        this.name = name;
        this.address = address;
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public String getAddress() {
        return address;
    }

    public int getId() {
        return id;
    }

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

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        } else if (!(obj instanceof Employee)) {
            return false;
        } else {
            Employee other = (Employee) obj;
            return Objects.equals(name, other.name)
                    && Objects.equals(address, other.address)
                    && id == other.id;
        }
    }

    @Override
    public String toString() {
        return "Employee[name=" + name + ", address=" + address + ", id=" + id + "]";
    }
}

While this accomplishes our goal, there are two problems with it:

• There’s a lot of boilerplate code
• We obscure the purpose of our class: to represent an employee with a name, address, and id

In the first case, we have to repeat the same tedious process for each data class, monotonously creating a new field for each piece of data; creating equals, hashCode, and toString methods; and creating a constructor that accepts each field. While IDEs can automatically generate many of these classes, they fail to automatically update our classes when we add a new field.

In the second case, we have to explicitly state the properties of our class, such as immutability, equality, and representation, which are not obvious from the class declaration. Moreover, we have to ensure that these properties are consistent and correct throughout the class, which can be error-prone and difficult to maintain.

Records solve these problems by providing a concise and expressive way to declare data classes, with minimal syntax and maximum functionality. Records automatically generate the fields, the constructor, the getters, the equals, hashCode, and toString methods, and the canonical constructor, based on the type and name of the fields declared in the record header. Records also implicitly declare the properties of the class, such as immutability, transparency, and consistency, which are clear and reliable.

Benefits of Records

Records have several advantages over regular classes when it comes to representing data. Some of them are:

• Records are immutable by default, which means that their state cannot be changed after creation. This makes them safer to use in concurrent and distributed environments.
• Records are concise and expressive, which means that they only require the type and name of the fields to be declared. The compiler automatically generates the private final fields, the public constructor, the getters, the equals, hashCode, and toString methods, and the canonical constructor.
• Records are transparent, which means that they do not hide or obscure the data they contain. The fields of a record are always accessible through the getters, and the toString method provides a clear representation of the state of the record.
• Records are consistent, which means that they follow the same conventions and contracts as regular classes. They can implement interfaces and be used as generic type parameters. However, records cannot be extended by other records or classes.

Declaring and Using Records

To declare a record, we use the keyword record followed by the name of the record and the list of fields in parentheses. For example, we can declare a record to represent an Employee with id, name, and address:

record Employee(String name, String address, int id) {}

To create an instance of a record, we use the new keyword and pass the values for the fields in the same order as they are declared. For example, we can create an employee object as follows:

Employee employee = new Employee("John Doe", "456 Oak Avenue", 12345);

To access the fields of a record, we use the getters that have the same name as the fields. For example, we can get the ID, name, and address of the employee object as follows:

String employeeName = employee.name();
String employeeAddress = employee.address();
int employeeId = employee.id();

To print the state of a record, we use the toString method that is automatically generated by the compiler. For example, we can print the employee object as follows:

System.out.println(employee);
// Output: Employee[name=John Doe, address=456 Oak Avenue, id=12345]

With Java Records, handling employee data becomes a breeze, offering a clean and readable way to manage information without the need for extensive boilerplate code.

Customizing Records

Records are not meant to be fully-fledged classes with complex logic and behavior. However, sometimes we may need to add some customization to records, such as validation, formatting, or computation. Records allow us to do that by providing the following options:

1. Static Fields & Methods

We can define static fields and static methods inside a record, just like in a regular class. For example, we can define a static field to store the number of instances of a record, and a static method to get that number:

record Employee(String name, String address, int id) {
    private static int count = 0;

    public Employee {
        count++;
    }

    public static int getCount() {
        return count;
    }
}

2. Instance Methods

We can define instance methods inside a record, just like in a regular class. For example, we can define an instance method to get the complete details of an Employee:

record Employee(String name, String address, int id) {
    public String getDetails() {
        return "Employee ID: " + id + ", Name: " + name + ", Address: " + address;
    }
}

3. Annotations

Annotations can be seamlessly incorporated into record components, allowing for enhanced customization. For instance, the @Transient annotation can be applied to exclude the id field from certain processes.

record Employee(String name, String address, @Transient Log id) {}

4. Constructors

We can define constructors inside a record, but they have some restrictions.

Automatic Canonical Constructor:

• A canonical constructor is automatically generated for each record.
• It initializes all the components (fields) of the record in the order they are declared.

Parameterless Constructor Flexibility:

• It’s allowed to create a constructor with no parameters in a Java record.
• If such a constructor is used, it must explicitly invoke the canonical constructor using this for field initialization.

Same Signature Flexibility:

• Additional constructors in a record can have a different signature than the canonical constructor.
• If the signature differs, the additional constructor must explicitly invoke the canonical constructor using this.

Explicit Invocation Requirement

• When additional constructors are defined in a record, they must explicitly invoke the canonical constructor using this.

Compact Constructors:

• Compact constructors share the same signature as the canonical constructor.
• Naming consistency between parameters and fields is crucial; they must match to avoid compile-time errors.
• In this case, a call to the canonical constructor is not required using this.

Validation and Initialization Logic:

• initialization and validation logic should be primarily included in the canonical constructor.

Constructor Example:

The Employee record showcases versatile constructor usage, including a canonical constructor with validation, variants with different parameter counts, and a private method for generating default employee IDs.

record Employee(String name, String address, int id) {

    // Canonical constructor with validation logic
    public Employee {
        if (name == null || name.isBlank() || address == null || address.isBlank()) {
            throw new IllegalArgumentException("Name and address cannot be null or blank");
        }
        // Additional logic for initialization or validation can go here
    }

    // Constructor with fewer parameters, invoking the canonical constructor
    public Employee(String name, String address) {
        this(name, address, generateDefaultId());
    }

    // Constructor with more parameters, invoking the canonical constructor
    public Employee(String name, String address, int id, boolean isActive) {
        this(name, address, id);
        // Additional logic for handling isActive parameter
    }

    // A method to generate a default employee id
    private static int generateDefaultId() {
        // Implement your logic to generate default id here
        return 0;
    }
}

5. Hash Code Method

We can customize the hashCode method that will allow us to define how the hash code is generated. If not customized, it is automatically generated based on all components of the record.

For instance, in an Employee record, we might include the hash codes of specific fields.

record Employee(String name, String address, int id) {
    // Other fields and methods...

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

6. Equals Method

We can customize the equals method to specify how equality between two instances of your record should be determined. If left untouched, Java will automatically generate the equals method based on all components of the record.

For instance, in an Employee record, we might want to compare the name, address, and id fields for equality.

record Employee(String name, String address, int id) {
    // Other fields and methods...

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Employee employee = (Employee) obj;
        return id == employee.id && Objects.equals(name, employee.name) && Objects.equals(address, employee.address);
    }
}

7. toString Method

We can customize the toString method that will allow us to format the string representation of the record. If not customized, it is automatically generated based on all components of the record.

For example, in an Employee record, we might display specific fields.

record Employee(String name, String address, int id) {
    // Other fields and methods...

    @Override
    public String toString() {
        return "Employee{" + "name='" + name + '\'' + ", address='" + address + '}';
    }
}

Records Limitations

1. Limited Inheritance

Records implicitly extend the java.lang.Record class, and explicit inheritance of records is restricted. This means records cannot be part of an inheritance hierarchy as a superclass or subclass.

2. Fixed Instance Variables

The instance variables (fields) of a record are automatically generated based on the constructor parameters. Once defined, these variables cannot be modified or extended, limiting flexibility in terms of additional instance variables. No new instance variables are allowed beyond those defined in the constructor.

3. Immutability by Default

Records are designed to be immutable by default, ensuring that their state cannot be changed after creation. While immutability is advantageous for data integrity, it might be restrictive in scenarios where mutable objects are required.

Java Records vs Java Classes: A Quick Comparison

When it comes to handling data in Java, understanding the differences between records and classes is crucial. Let’s explore the distinctions to help you make informed decisions in your coding journey.

Things to Consider

Here are some key considerations when using the Java Record:

• Immutability Trade-Off: While records are designed for immutability, carefully evaluate scenarios where mutable behavior might be necessary.
• Inheritance Use Cases: Consider the limitations of records in inheritance scenarios. Assess whether inheritance is a critical requirement for your class hierarchy.
• Method Customization: Understand the implications of customizing methods like hashCode, equals, and toString. Evaluate if default behavior suffices or requires modification.
• External Libraries Compatibility: Check for compatibility with external libraries and frameworks, as some may not fully support or integrate seamlessly with Java records.

FAQs

Conclusion

In summary, Java records make it much easier to create classes that hold data. They do this by providing a shorter way to write the code and automatically creating some common methods for us. This not only makes our code shorter and easier to read but also helps ensure that our data is kept safe and unchangeable. Java records are like a handy tool for developers, helping them write better code and build more reliable data structures. So, using records in Java is a smart choice for anyone working on projects where handling data is important.

Learn More

Top Picks for Learning Java

Explore the recommended Java books tailored for learners at different levels, from beginners to advanced programmers.

Disclaimer: The products featured or recommended on this site are affiliated. If you purchase these products through the provided links, I may earn a commission at no additional cost to you.

1

13th Edition

Java: The Complete Reference

• All Levels Covered: Designed for novice, intermediate, and professional programmers alike
• Accessible Source Code: Source code for all examples and projects are available for download
• Clear Writing Style: Written in the clear, uncompromising style Herb Schildt is famous for

4.6

Check Price - IndiaCheck Price - Global

2

Head First Java: A Brain-Friendly Guide

• Engaging Learning: It uses a fun approach to teach Java and object-oriented programming.
• Comprehensive Content: Covers Java's basics and advanced topics like lambdas and GUIs.
• Interactive Learning: The book's visuals and engaging style make learning Java more enjoyable.

4.6

Check Price - IndiaCheck Price - Global

3

2nd Edition

Modern Java in Action: Lambdas, streams, functional and reactive programming

• Latest Java Features: Explores modern Java functionalities from version 8 and beyond, like streams, modules, and concurrency.
• Real-world Applications: Demonstrates how to use these new features practically, enhancing understanding and coding skills.
• Developer-Friendly: Tailored for Java developers already familiar with core Java, making it accessible for advancing their expertise.

4.6

Check Price - IndiaCheck Price - Global

4

8th Edition

Java For Dummies

• Java Essentials: Learn fundamental Java programming through easy tutorials and practical tips in the latest edition of the For Dummies series.
• Programming Basics: Gain control over program flow, master classes, objects, and methods, and explore functional programming features.
• Updated Coverage: Covers Java 17, the latest long-term support release, including the new 'switch' statement syntax, making it perfect for beginners or those wanting to brush up their skills.

4.5

Check Price - IndiaCheck Price - Global