An Overview of Java 17 Records
Initially provided as a preview in Java 14 and finished in Java 16, the continuous development of records is one of the key concepts that gained popularity in Java 17. In keeping with its goal of streamlining Java code and cutting down on boilerplate, Java 17 records more reliable and user-friendly in a variety of situations. Records, a feature added in Java 17, make it easier to create classes that are mostly used for data storage. In Java web application development, a record is a unique class type that was first used as a preview feature in Java 14 and stabilized in Java 16. Java 17 still relies heavily on records.
- A constructor that has parameters for every field is known as a canonical constructor.
- Getter Methods: Named after the fields, these methods are used to access each one.
- tostring() – is used to return a string representation of a record.
What is a Java Record?
A Record is a special type of class in Java used to store immutable data. It automatically generates :
- A Constructor
- Getter Methods (for all fields)
- equal(), hashcode(), toString() methods based on the fields defined in the record.
READ – Sealed Classes in Java: Benefits and Syntax Explained
Why Use Records?
When you wish to build POJOs (Plain Old Java Objects), or basic data carriers, you may utilize records to avoid writing boilerplate code for constructors, getters, equals, hashCode, and toString methods by hand.
Syntax for Records in Java
The record keyword, the record’s name, and the fields it will include are used to define a record.
public record Person(String name, int age) {
// Custom methods can be added when needed
}
In the above example :
- Person is a record that contains two fields i.e. name( a String) and age(an int).
- Compiler automatically generates :
- Constructor Person(String name, int age)
- Getter Methods like : name() and age()
- Equals(), hasCode(), toString() implementations.
Example of Using Java 17 Records
public class Main {
// Define a record called 'Person'
public record Person(String name, int age) {}
public static void main(String[] args) {
// Create a new Person instance
Person person = new Person("John Doe", 30);
// Access fields using generated getter methods
System.out.println("Name: " + person.name());
System.out.println("Age: " + person.age());
// Display the automatically generated toString() method
System.out.println(person); // Output: Person[name=John Doe, age=30]
// Demonstrating the equality check based on record fields
Person person2 = new Person("John Doe", 30);
System.out.println("Is person equal to person2? " + person.equals(person2)); // true
// HashCode comparison (both should have the same hashCode)
System.out.println("person hashCode: " + person.hashCode());
System.out.println("person2 hashCode: " + person2.hashCode());
}
}
Output
Name: John Doe
Age: 30
Person[name=John Doe, age=30]
Is person equal to person2? true
person hashCode: 1424466118
person2 hashCode: 1424466118
Key Features of Record
- Immutable: By default, records are immutable, which means that once an instance is created, its fields cannot be altered.
- Consice Syntax: No need to manually write Constructors, Getter Methods like toString(), hashcode(), equals().
- Constructor: If necessary for transformation or validation, you can define a custom constructor.
- Compact and Readable: It makes code more compact and readable, especially for data-carrying objects.
Additional Customization
- We can add Methods in a record.
- In order to validate the data we can define the custom constructor.
- Default behaviour of methods like equals(), hashCode(), toString() can be override when needed.
Example with a Custom Constructor
public record Person(String name, int age) {
// Custom constructor for validation
public Person {
if (age < 0) {
throw new IllegalArgumentException("Age cannot be negative");
}
}
// Custom method
public String greet() {
return "Hello, " + name;
}
}
An exception will be raised in this case if you attempt to create a person with a negative age.
Limitations of Records
- Here the fields are implicitly final which means their values can’t be changed.
- A record can implement interfaces but cannot extend another class.
- Records cannot have instance fields that are mutable.
In Java 17 and beyond, records are a fantastic method to interact with immutable data types and cut down on boilerplate code!
Conclusion
To sum up, Java records — which were first introduced in Java 14 and solidified in Java 16 — are a strong feature that makes creating data-holding classes easier. They drastically cut down on boilerplate code by automatically generating necessary methods like constructors, getters, equals(), hashCode(), and toString(). For basic data structures, records provide a more succinct and understandable method of class definition while fostering immutability.
With Java 17 Records, Java developers can easily create immutable data classes, streamlining code and enhancing readability without sacrificing performance. Records offer a streamlined, effective method of handling immutable data in contemporary Java Web Development programs, despite their limitations, including their inability to enable inheritance, and their default immutability.
Read more:
