Java Records: Simplify Data Classes

By Atul Rai | Last Updated: August 13, 2023 Previous       Next

The record keyword was introduced in Java 16. It is a feature that simplifies the creation of classes for data storage by automatically generating methods such as constructors, getters, equals(), hashCode(), and toString(). Java records were added as a preview feature in Java 14 and became a standard feature starting from Java 16.

Java records provide a concise and efficient way to define classes for data storage, reducing the boilerplate code typically associated with creating such classes. In this blog post, we will explore Java records, understand their usage, advantages, and even touch upon their limitations.

1. Understanding Java Records

Java records can be thought of as a more specialized version of classes designed to hold data. They are declared using the record keyword, followed by the class name and a list of components (data fields). Each component defines a piece of data that the record will store.

Let’s look at a simple example:

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

In this example, we have defined a Person record with two components: name of type String and age of type int. This automatically generates constructors, getters, equals(), hashCode(), and toString() methods for us.

2. Usage of Java Records

Java records are particularly useful when dealing with data objects that don’t have complex behaviors or methods associated with them. They excel in scenarios where the primary purpose is to store and retrieve data. Records make the code cleaner and more maintainable by reducing the amount of boilerplate code that needs to be written.

3. Advantages of Java Records

1. Concise Syntax: Records provide a succinct way to define classes solely for data storage, eliminating the need for redundant code.
2. Automatic Methods: Records generate essential methods like constructors, getters, equals(), and hashCode() automatically, reducing the likelihood of errors.
3. Immutability: By default, record components are made final, promoting immutability and enhancing data integrity.
4. Readability: The streamlined code of records improves code readability and makes it easier to understand the data structure.

4. Disadvantage of Java Records

1. Limited Behavior: Records are not suitable for classes with complex behaviors or methods. They are designed primarily for data storage and retrieval.

Here are a few live examples of Java records to help you better understand how they work:

Example 1: Point Coordinates

public record Point(int x, int y) {
    // No need to explicitly define constructors, getters, equals(), hashCode(), or toString()
}

public class RecordExample {
    public static void main(String[] args) {
        Point point = new Point(5, 10);
        System.out.println("Point coordinates: " + point);
    }
}

Example 2: Student Information

public record Student(String name, int age, String course) {
}

public class RecordExample {
    public static void main(String[] args) {
        Student student = new Student("Manish", 30, "Computer Science");
        System.out.println("Student information: " + student);
    }
}

Example 3: Person Details

public record Person(String name, int age, List<String> hobbies) {
}

public class RecordExample {
    public static void main(String[] args) {
        List<String> hobbies = List.of("Reading", "Hiking", "Cooking");
        Person person = new Person("Manish", 30, hobbies);
        
        System.out.println("Person: " + person.name());
        System.out.println("Age: " + person.age());
        System.out.println("Hobbies: " + person.hobbies());
    }
}

In each of these examples, we define a Java record with a few components (data fields). The compiler automatically generates the necessary methods, such as constructors, getters, equals(), hashCode(), and toString(). This eliminates the need for writing repetitive boilerplate code.

You can create instances of these records just like you would with regular classes, and access their components using the generated getters. This simplicity and automatic generation of methods make Java records an excellent choice for data storage classes.

Summary

Java records are a powerful addition to the Java language, simplifying the creation of data-centric classes and reducing boilerplate code. They are best suited for scenarios where the main focus is on storing and retrieving data rather than implementing complex behaviors. By embracing records, developers can write cleaner, more concise code, improving code readability and maintainability.

References

1. JEP 395: Records