Dado el siguiente código:

public static void main(String[] args) {
    record Foo(int[] ints){}

    var ints = new int[]{1, 2};
    var foo = new Foo(ints);
    System.out.println(foo); // Foo[ints=[I@6433a2]
    System.out.println(new Foo(new int[]{1,2}).equals(new Foo(new int[]{1,2}))); // false
    System.out.println(new Foo(ints).equals(new Foo(ints))); //true
    System.out.println(foo.equals(foo)); // true
}

Parece, por supuesto, de esa matriz toString, equalslos métodos se utilizan (en lugar de los métodos estáticos,Arrays::equals , Arrays::deepEquals o Array::toString).

Así que supongo que Java 14 Records ( JEP 359 ) no funcionan demasiado bien con las matrices, los métodos respectivos tienen que generarse con un IDE (que al menos en IntelliJ, por defecto genera métodos "útiles", es decir, usan los métodos estáticos en Arrays).

¿O hay alguna otra solución?

Las matrices Java plantean varios desafíos para los registros, y estos agregaron una serie de restricciones al diseño. Las matrices son mutables, y su semántica de igualdad (heredada de Object) es por identidad, no por contenido.

El problema básico con su ejemplo es que desea que equals()en las matrices signifique igualdad de contenido, no igualdad de referencia. La semántica (predeterminada) equals()para los registros se basa en la igualdad de los componentes; en su ejemplo, los dos Fooregistros que contienen matrices distintas son diferentes y el registro se comporta correctamente. El problema es que solo desearías que la comparación de igualdad fuera diferente.

Dicho esto, puede declarar un registro con la semántica que desee, solo requiere más trabajo y puede sentir que es demasiado trabajo. Aquí hay un registro que hace lo que quieres:

record Foo(String[] ss) {
    Foo { ss = ss.clone(); }
    String[] ss() { return ss.clone(); }
    boolean equals(Object o) { 
        return o instanceof Foo 
            && Arrays.equals(((Foo) o).ss, ss);
    }
    int hashCode() { return Objects.hash(Arrays.hashCode(ss)); }
}

Lo que esto hace es una copia defensiva al entrar (en el constructor) y al salir (en el descriptor de acceso), así como ajustar la semántica de igualdad para usar los contenidos de la matriz. Esto es compatible con el invariante, requerido en la superclasejava.lang.Record , que "separar un registro en sus componentes y reconstruir los componentes en un nuevo registro, produce un registro igual".

Bien podría decir "pero eso es demasiado trabajo, quería usar registros para no tener que escribir todo eso". Pero los registros no son principalmente una herramienta sintáctica (aunque son sintácticamente más agradables), son una herramienta semántica: los registros son tuplas nominales . La mayoría de las veces, la sintaxis compacta también produce la semántica deseada, pero si desea una semántica diferente, debe realizar un trabajo adicional.

List< Integer > solución alterna

Solución alternativa: utilice a Listof Integerobjects ( List< Integer >) en lugar de una matriz de primitivas ( int[]).

En este ejemplo, ejemplifico una lista no modificable de clase no especificada usando la List.ofcaracterística agregada a Java 9. También podría usar ArrayList, para una lista modificable respaldada por una matriz.

package work.basil.example;

import java.util.List;

public class RecordsDemo
{
    public static void main ( String[] args )
    {
        RecordsDemo app = new RecordsDemo();
        app.doIt();
    }

    private void doIt ( )
    {

        record Foo(List < Integer >integers)
        {
        }

        List< Integer > integers = List.of( 1 , 2 );
        var foo = new Foo( integers );

        System.out.println( foo ); // Foo[integers=[1, 2]]
        System.out.println( new Foo( List.of( 1 , 2 ) ).equals( new Foo( List.of( 1 , 2 ) ) ) ); // true
        System.out.println( new Foo( integers ).equals( new Foo( integers ) ) ); // true
        System.out.println( foo.equals( foo ) ); // true
    }
}

Solución alternativa: cree unaIntArrayclase y ajuste elint[].

record Foo(IntArray ints) {
    public Foo(int... ints) { this(new IntArray(ints)); }
    public int[] getInts() { return this.ints.get(); }
}

No es perfecto, porque ahora tienes que llamar en foo.getInts()lugar de hacerlo foo.ints(), pero todo lo demás funciona de la manera que deseas.

public final class IntArray {
    private final int[] array;
    public IntArray(int[] array) {
        this.array = Objects.requireNonNull(array);
    }
    public int[] get() {
        return this.array;
    }
    @Override
    public int hashCode() {
        return Arrays.hashCode(this.array);
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null || getClass() != obj.getClass())
            return false;
        IntArray that = (IntArray) obj;
        return Arrays.equals(this.array, that.array);
    }
    @Override
    public String toString() {
        return Arrays.toString(this.array);
    }
}

Salida

Foo[ints=[1, 2]]
true
true
true