Biorąc pod uwagę następujący kod:

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
}

Wydaje się, oczywiście, na tej tablicy toString, equalssposoby są stosowane (zamiast metod statycznych Arrays::equals, Arrays::deepEquals bądź Array::toString).

Sądzę więc, że Java 14 Records ( JEP 359 ) nie działa zbyt dobrze z tablicami, odpowiednie metody muszą zostać wygenerowane za pomocą IDE (które przynajmniej w IntelliJ domyślnie generuje „przydatne” metody, tj. Używają metod statycznych w Arrays).

Czy jest jakieś inne rozwiązanie?

Macierze Java stanowią kilka wyzwań dla rekordów, które dodały wiele ograniczeń w projekcie. Tablice są zmienne, a ich semantyka równości (dziedziczona z Object) jest oparta na tożsamości, a nie na zawartości.

Podstawowym problemem związanym z twoim przykładem jest to, że chciałbyś, aby equals()tablice oznaczały równość treści, a nie równość odniesienia. (Domyślna) semantyka dla equals()rekordów oparta jest na równości składników; w twoim przykładzie dwa Foorekordy zawierające odrębne tablice są różne, a rekord zachowuje się poprawnie. Problem polega na tym, że po prostu chciałbyś, aby porównanie równości było inne.

To powiedziawszy, możesz zadeklarować rekord z pożądaną semantyką, to po prostu wymaga więcej pracy i możesz poczuć, że to zbyt wiele pracy. Oto rekord, który robi to, co chcesz:

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

To robi obronną kopię na wejściu (w konstruktorze) i na wyjściu (w akcesorium), a także dostosowuje semantykę równości do korzystania z zawartości tablicy. Wspiera to niezmiennik wymagany w nadklasie java.lang.Record, który „rozebranie rekordu na jego komponenty i przebudowanie komponentów na nowy rekord, daje taki sam rekord”.

Można powiedzieć: „ale to za dużo pracy, chciałem używać płyt, więc nie musiałem wpisywać tych wszystkich rzeczy”. Ale rekordy nie są przede wszystkim narzędziem składniowym (chociaż są przyjemniejsze składniowo), są narzędziem semantycznym: rekordy są krotkami nominalnymi . Przez większość czasu zwarta składnia daje również pożądaną semantykę, ale jeśli chcesz mieć inną semantykę, musisz wykonać dodatkową pracę.

List< Integer > obejście

Rozwiązanie: Użyć Listz Integerprzedmiotów ( List< Integer >) niż szereg pierwotnych ( int[]).

W tym przykładzie tworzę instancję niemodyfikowalnej listy nieokreślonej klasy, używając List.offunkcji dodanej do Java 9. Równie dobrze możesz użyć ArrayListdo modyfikowalnej listy wspieranej przez tablicę.

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

Obejście: UtwórzIntArrayklasę i zawińint[].

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

Nie idealnie, bo teraz musisz dzwonić foo.getInts()zamiast foo.ints(), ale wszystko inne działa tak, jak chcesz.

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

Wynik

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