The syntax for creating a record in Java is as follows:

record Record_Name(Fields….)

Example:

public record Book(String name, double price) { }

This creates a new record called “Book” with two fields: “name” and “price”.

You may also read: Java 14 Features and  Java 17 Features

How to create and use Record in Java With Examples?

Let’s understand how to create and use a record in java programmatically.

Creating a Record

Programmatically, creating a record is not very similar to creating a regular class in Java. We use ‘record’ keyword instead of ‘class’. Furthermore, declare the fields with data types within the bracket of record name. For example, below code demonstrates how to create a record in Java:

public record Book(String name, double price) { }

As shown in this example, we have created a record called “Book” with two fields: “name” and “price”. The “public” keyword indicates that this record can be accessed from outside the package it is defined in.

Using a Record

To use a record in Java, we can create an instance of it using the “new” keyword, just like we do with a regular class. Here is an example:

Book book = new Book("Core Java", 324.25);

This creates a new instance of the “Book” record with the “name” field set to “Core Java” and the “price” field set to 324.25. Once a record has been created, its fields can be accessed using the field name itself. There are no getter & setter methods. Instead, field name becomes the method name.

String name = book.name(); 

double price = book.price();

This retrieves the value of the “name” and “price” fields from the “book” record.

In addition to the fields, records also have some built-in methods that can be used to manipulate them. For example, toString(), equals() and hashCode().

Records in Java are immutable by default, which means that once they have been created, their state cannot be changed.

Let’s take a look at some other example of how to create & use records in Java.

Example:

Let’s take an example of a record for storing student information.

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

This creates a record called “Student” with three fields: “name”, “age”, and “subject”. We can create an instance of this record as follows:

Student student = new Student("John Smith", 20, "Computer Science");

We can then retrieve the values of the fields using the field name:

String name = student.name();
int age = student.age(); 
String subject= student.subject();

How does a Record look like after Compilation?

As record is simply a special kind of a class and the compiler also converts it into a normal class, but with some restrictions, which makes it slightly different from the typical classes. When the compiler converts the record (Java file) into the bytecode after compilation process, the produced ‘.class’ file contains some additional declarations of the record class. For example, below is the bytecode produced for the Student record by the java compiler:

Record in Java File 

record Student(String name, int age) {   }

Record in .class file (After Compilation)

We can also find below converted class if we use javap tool and apply below command from command prompt. It is important to note that the Java command-line includes the ‘javap’ tool, which can be used to view details about the fields, constructors, and methods of a class file.

>javap Student

Conclusion: If we check the bytecode closely, we can have some observations:

• The compiler has replaced the record keyword by class.
• The compiler has declared class as final. This indicates that this class cannot be extended. It also means that it cannot be inherited, and is immutable in nature.
• The converted class extends java.lang.Record. It indicates that all records are a subclass of the Record class defined under java.lang package.
• There is a parameterized constructor added by the compiler.
• The compiler has auto-generated the toString(), hashCode(), and equals() methods.
• The compiler has added methods to access the fields. Note that naming convention of the methods. They are exactly matching with the names of the fields, no get or set before the field names.

public class Person {

    private String name;
    private int age;
    private String email;

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

    public String getName() {

       return name;
    }

    public int getAge() {
       return age;
    }
    
    publicString getEmail() {
       return email;
    }

    public void setName(String name) {
       this.name = name;
    }

    public voidsetAge(int age) {
       this.age = age;
    }

    public void setEmail(String email) {
       this.email = email;
    }

    @Override
    public String toString() {
       return "Person{" +
         "name='" + name + '\'' +
         ", age=" + age +
         ", email='" + email + '\'' +
      '}';
    }
}

As we can see, this class requires a lot of boilerplate code to define the fields, constructor, getters, setters, and toString() method.

Apart from this, suppose we want to make this class immutable. Then we have to do some additional steps such as:

1. Declare the class as final, so it cannot be extended.
2. Declare all fields as private and final, so they cannot be modified outside the constructor.
3. Do not provide any setter methods for the fields.
4. If any of the fields are mutable, return a copy of them instead of returning the original object.

Code Using Record

Now let’s see how we can define the same class using a Java record:

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

That’s it! With just one line of code, we have defined a class that has the same fields, constructor, getters, setters, and toString() method as the traditional class. The record syntax takes care of all the boilerplate code for us.

In Java, it is also possible to define generic record classes. A generic record class is a record class that has one or more type parameters. Here is an example:

public record Pair<T, U>(T first, U second) {}

In this example, Pair is a generic record class that takes two type parameters T and U. We can create an instance of this record as follows:

Pair<String, Integer> pair = new Pair<>("Hello", 123);