Étant donné le code suivant:

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
}

Il semble, de toute évidence, de ce tableau toString, les equalsméthodes sont utilisées ( au lieu de méthodes statiques, Arrays::equals, Arrays::deepEquals ou Array::toString).

Donc je suppose que les enregistrements Java 14 ( JEP 359 ) ne fonctionnent pas trop bien avec les tableaux, les méthodes respectives doivent être générées avec un IDE (qui au moins dans IntelliJ, génère par défaut des méthodes "utiles", c'est-à-dire qu'elles utilisent les méthodes statiques dans Arrays).

Ou existe-t-il une autre solution?

Les tableaux Java posent plusieurs défis pour les enregistrements, et ceux-ci ont ajouté un certain nombre de contraintes à la conception. Les tableaux sont modifiables et leur sémantique d'égalité (héritée d'Object) est basée sur l'identité et non sur le contenu.

Le problème de base avec votre exemple est que vous souhaitez que equals()sur les tableaux signifie l'égalité de contenu, pas l'égalité de référence. La sémantique (par défaut) equals()pour les enregistrements est basée sur l'égalité des composants; dans votre exemple, les deux Fooenregistrements contenant des tableaux distincts sont différents et l'enregistrement se comporte correctement. Le problème est que vous souhaitez juste que la comparaison d'égalité soit différente.

Cela dit, vous pouvez déclarer un enregistrement avec la sémantique que vous souhaitez, cela prend juste plus de travail, et vous pouvez penser que c'est trop de travail. Voici un enregistrement qui fait ce que vous voulez:

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)); }
}

Ce que cela fait, c'est une copie défensive à l'entrée (dans le constructeur) et à la sortie (dans l'accesseur), ainsi qu'en ajustant la sémantique d'égalité pour utiliser le contenu du tableau. Cela prend en charge l'invariant, requis dans la superclasse java.lang.Record, que "démonter un enregistrement dans ses composants et reconstruire les composants dans un nouvel enregistrement, donne un enregistrement égal".

Vous pourriez bien dire "mais c'est trop de travail, je voulais utiliser des disques donc je n'ai pas eu à taper tout ça." Mais, les enregistrements ne sont pas principalement un outil syntaxique (bien qu'ils soient syntaxiquement plus agréables), ils sont un outil sémantique: les enregistrements sont des tuples nominaux . La plupart du temps, la syntaxe compacte produit également la sémantique souhaitée, mais si vous voulez une sémantique différente, vous devez faire un travail supplémentaire.

List< Integer > solution de contournement

Solution: Utiliser un Listdes Integerobjets ( List< Integer >) plutôt que de tableau de primitives ( int[]).

Dans cet exemple, j'instancie une liste non modifiable de classe non spécifiée en utilisant la List.offonctionnalité ajoutée à Java 9. Vous pouvez tout aussi bien l'utiliser ArrayList, pour une liste modifiable appuyée par un tableau.

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
    }
}

Solution: créez uneIntArrayclasse et encapsulez le fichierint[].

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

Pas parfait, car vous devez maintenant appeler foo.getInts()au lieu de foo.ints(), mais tout le reste fonctionne comme vous le souhaitez.

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);
    }
}

Production

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