Records

Records were introduced in Java 14 as a preview feature and became a permanent feature starting from Java 16. They provide a concise way to declare classes that are essentially immutable data carriers. Records can be used to model data-centric classes without the boilerplate associated with traditional Java classes.

Key Features of Records:

  1. Immutable Data: Record instances are immutable by default, meaning their state cannot be modified once they are created. This immutability is achieved by making the components (fields) of a record final.

  2. Automatic Accessors: Records automatically generate accessor methods (getters) for their components, allowing easy retrieval of field values.

  3. Compact Syntax: Records have a concise syntax for defining data-centric classes, reducing the amount of boilerplate code required.

  4. equals() and hashCode(): Records automatically generate equals() and hashCode() methods based on their components. These methods provide value-based equality semantics, comparing the values of all components for equality.

  5. toString(): Records automatically generate a toString() method that provides a string representation of the record's state. This string representation includes the names and values of all components.

Syntax of Declaring a Record:

public record Person(String name, int age) {
    // Record components and methods (if any)
}

Example Usage:

public class Main {

    public static void main(String[] args) {

        // Creating a record instance

        Person person = new Person("Alice", 30);


        // Accessing record components

        System.out.println(person.name()); // Output: Alice

        System.out.println(person.age());  // Output: 30


        // Automatically generated toString() method

        System.out.println(person); // Output: Person[name=Alice, age=30]


        // Automatically generated equals() method

        Person person2 = new Person("Alice", 30);

        System.out.println(person.equals(person2)); // Output: true

    }

}

Benefits of Records:

  • Conciseness: Records provide a concise way to define data-centric classes, reducing boilerplate code.
  • Readability: The automatically generated methods and compact syntax make records easy to read and understand.
  • Immutability: Records are immutable by default, promoting a functional programming style and reducing the risk of accidental state changes.
  • Safety: Value-based equality and immutable state make records safer to use in concurrent and multi-threaded environments.

Limitations:

  • Immutability: While records are immutable by default, it is still possible to define mutable components within a record, which can lead to unexpected behavior.
  • Extensibility: Records cannot extend other classes, as they implicitly extend java.lang.Record and cannot have additional superclasses.

Overall, records provide a powerful and concise way to model data in Java, improving code readability and reducing boilerplate. They are particularly useful for representing DTOs (Data Transfer Objects), POJOs (Plain Old Java Objects), and other data-centric classes. 

Comments

Post a Comment

Popular posts from this blog

Transform values with a stream

The goal is to transform an array of numbers into a comma-delimited string using functional programming. The code snippet you provided has a minor issue: String.join(",", strings[0]) is incorrect because it tries to join a single element ( strings[0] ) rather than all elements in the strings array. Here's the corrected code for the transformValues method: import java.util.Arrays; class Answer {     // Change these boolean values to control whether you see      // the expected answer and/or hints.     static boolean showExpectedResult = true;     static boolean showHints = true;     // Transform an array of numbers into a comma-delimited list     // using functional programming.     static String transformValues(int[] numbers) {         // Convert the int array to a stream of integers         // Map each integer to its String representation         // ...
Read more

Collections Framework

 The Java Collections Framework provides a comprehensive set of interfaces, implementations, and algorithms to work with collections of objects in Java. It offers a unified architecture for representing and manipulating collections, making it easier to work with data structures in Java programs. The Collections Framework is a fundamental part of Java programming and is widely used in various applications ranging from simple data manipulation tasks to complex algorithms and data processing pipelines.  Key components of the Collections Framework: Interfaces Collection : The root interface of the Collections Framework hierarchy. Represents a group of objects, known as elements. Subinterfaces include List , Set , and Queue . List : Represents an ordered collection of elements where duplicate elements are allowed. Allows elements to be accessed and inserted by index. Implementations include ArrayList , LinkedList , and Vector . Set : Represents a collection of unique elements ...
Read more

Inspect a collection

Calculate the cart total  import java.util.List; import java.util.concurrent.atomic.AtomicReference; public class Main {     public static void main(String[] args) {         List<Item> items = List.of(             new Item("Item1", 10.0f, 2),             new Item("Item2", 5.0f, 4),             new Item("Item3", 20.0f, 1)         );         float total = getCartTotal(items);         System.out.println("Cart Total: " + total);  // Output: Cart Total: 60.0     }     static float getCartTotal(List<Item> items) {         AtomicReference<Float> total = new AtomicReference<>(0.0f);         items.forEach(item -> {             total.updateAndGet(v -> v + item.getQuantity() * item.getPrice())...
Read more