A record is a structure that is characterized by being immutable, that is, once an object of type record has been created. , its attributes cannot be modified, it is the equivalent of what other programming languages ​​call data-class or DTO (Data Transfer Object). However, if an attribute is required to be modified using a setter method and considering that each attribute within the record is of final type, how can this be achieved?

To show if this is possible, let's create a record Product that has two attributes name and price, and the respective methods that are automatically created when defining a record in Java:

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

Now, if you create an object of type Product and try to modify the name attribute, you can see that it is not possible, and there is not even a setter method to do it:

Product p = new Product("Bread", 1.0);
p.setName("Water"); // Error: cannot resolve method 'setName' in 'Product'

But, if we know that a record can have additional methods, then we can create a setName(String name) method that modifies the name attribute and assigns the new value, because the answer is no , it doesn't work like it would in a normal class, for example:

public record Product(String name, double price) {
    // Error: cannot asign a value to final variable 'name'
    public void setName(String name) {
        this.name = name;
    }
}

So how can you modify an attribute of a record in Java? The answer is that it can if the set method returns a new instance of record with each of its attributes and obviously with the modified attribute(s). This process can be a bit tedious depending on the number of attributes that record.
has.

public record Product(String name, double price) {

    public Product setName(String name) {
        return new Product(name, this.price);
    }

    public Product setPrice(double price) {
        return new Product(this.name, price);
    }

}

In this way, when invoking any of the setter methods, a new instance of the Product type with the modified attribute will be obtained, for example:

Product p = new Product("Bread", 1.0);
Product q = p.setName("Milk");
Product r = q.setPrice(2.0);

For each object p, q and r, its get, equals, hashCode and toString methods can be invoked normally, considering that none of the objects is equal to the other, since each one has a different value in its attributes.

public class Main {
    public static void main(String[] args) {
        Product p = new Product("Bread", 1.0);
        Product q = p.setName("Milk");
        Product r = q.setPrice(2.0);

        System.out.println(p); // Product[name=Bread, price=1.0]
        System.out.println(q); // Product[name=Milk, price=1.0]
        System.out.println(r); // Product[name=Milk, price=2.0]

        System.out.println(p.equals(q)); // false
        System.out.println(q.equals(r)); // false
        System.out.println(r.equals(p)); // false
    }
}

At this point, it is important to consider whether this approach is appropriate for the problem being solved, considering that a record is designed to be a structure that allows information to be stored and transported in a simple way. within an application and be immutable, or if a structure with greater flexibility is required, then a class should be used. For more information on when to use a record or a class, you can consult the following post.