Gegeben den folgenden Code:

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
}

Es scheint offensichtlich, das Arrays toString, equalsMethoden verwendet werden (anstelle von statischen Methoden Arrays::equals, Arrays::deepEquals oder Array::toString).

Ich denke, Java 14-Datensätze ( JEP 359 ) funktionieren mit Arrays nicht besonders gut. Die jeweiligen Methoden müssen mit einer IDE generiert werden (die zumindest in IntelliJ standardmäßig "nützliche" Methoden generiert, dh sie verwenden die statischen Methoden in Arrays).

Oder gibt es eine andere Lösung?

Java-Arrays stellen Datensätze vor verschiedene Herausforderungen, die dem Design eine Reihe von Einschränkungen hinzufügen. Arrays sind veränderlich und ihre Gleichheitssemantik (von Object geerbt) beruht auf Identität und nicht auf Inhalten.

Das Grundproblem bei Ihrem Beispiel besteht darin, dass Sie wünschen, dass equals()auf Arrays Inhaltsgleichheit und nicht Referenzgleichheit bedeutet. Die (Standard-) Semantik für equals()Datensätze basiert auf der Gleichheit der Komponenten. in Ihrem Beispiel sind die beiden FooDatensätze verschiedene Arrays enthalten sind unterschiedlich, und der Datensatz korrekt verhält. Das Problem ist nur, dass Sie sich wünschen, der Gleichheitsvergleich wäre anders.

Das heißt, Sie können einen Datensatz mit der gewünschten Semantik deklarieren, es erfordert nur mehr Arbeit, und Sie haben möglicherweise das Gefühl, dass dies zu viel Arbeit ist. Hier ist eine Aufzeichnung, die macht, was Sie wollen:

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

Dies ist eine defensive Kopie auf dem Weg nach innen (im Konstruktor) und auf dem Weg nach draußen (im Accessor) sowie die Anpassung der Gleichheitssemantik, um den Inhalt des Arrays zu verwenden. Dies unterstützt die in der Oberklasse geforderte Invariante, java.lang.Recorddass "das Zerlegen eines Datensatzes in seine Komponenten und das Rekonstruieren der Komponenten in einen neuen Datensatz einen gleichen Datensatz ergibt".

Man könnte sagen: "Aber das ist zu viel Arbeit. Ich wollte Datensätze verwenden, damit ich nicht all das Zeug eingeben muss." Datensätze sind jedoch nicht in erster Linie ein syntaktisches Werkzeug (obwohl sie syntaktisch angenehmer sind), sondern ein semantisches Werkzeug: Datensätze sind nominelle Tupel . Meistens liefert die kompakte Syntax auch die gewünschte Semantik. Wenn Sie jedoch eine andere Semantik wünschen, müssen Sie zusätzliche Arbeit leisten.

List< Integer > Problemumgehung

Umgehung: Verwenden Sie eine Listvon IntegerObjekten ( List< Integer >) statt Array von Primitiven ( int[]).

In diesem Beispiel instanziiere ich eine nicht modifizierbare Liste nicht spezifizierter Klassen mithilfe der List.ofzu Java 9 hinzugefügten Funktion. Sie können sie auch ArrayListfür eine modifizierbare Liste verwenden, die von einem Array unterstützt wird.

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

Problemumgehung: Erstellen Sie eineIntArrayKlasse und schließen Sie dieint[].

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

Nicht perfekt, weil Sie jetzt foo.getInts()statt anrufen müssen foo.ints(), aber alles andere funktioniert so, wie Sie es möchten.

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

Ausgabe

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