Дано наступний код:

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
}

Здається, очевидно, цей масив toString, equalsвикористовуються методи (замість статичних методів Arrays::equals, Arrays::deepEquals або Array::toString).

Тому я думаю, що записи Java 14 ( JEP 359 ) не надто добре працюють з масивами, відповідні методи повинні бути створені за допомогою IDE (який, принаймні, в IntelliJ, за замовчуванням генерує "корисні" методи, тобто вони використовують статичні методи в Arrays).

Або є якесь інше рішення?

Масиви Java створюють кілька проблем для записів, і це додало певних обмежень для дизайну. Масиви є змінними, і семантика їх рівності (успадкована від Object) - це ідентичність, а не зміст.

Основна проблема вашого прикладу полягає в тому, що ви хочете, щоб equals()на масивах малася на увазі рівність вмісту, а не рівність. Семантика (за замовчуванням) equals()для записів заснована на рівності компонентів; у вашому прикладі два Fooзаписи, що містять різні масиви , різні, і запис веде себе правильно. Проблема полягає в тому, що ви просто хочете, щоб порівняння рівності було іншим.

Однак, ви можете оголосити запис із потрібною семантикою. Це просто потребує більше роботи, і ви можете відчути, що це занадто велика робота. Ось запис, який робить те, що ви хочете:

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

Це робить захисну копію на шляху в (в конструкторі) і на виході (в аксесуар), а також коригування семантики рівності для використання вмісту масиву. Це підтримує інваріант, необхідний в суперкласі java.lang.Record, що "розділення запису на його компоненти та реконструкція компонентів у новий запис дає рівний запис".

Ви можете сказати, "але це занадто багато роботи, я хотів використовувати записи, тому мені не довелося вводити всі ці речі". Але записи - це, насамперед, не синтаксичний інструмент (хоча вони синтаксично приємніші), вони є семантичним інструментом: записи - це номінальні кортежі . Більшу частину часу компактний синтаксис також дає бажану семантику, але якщо ви хочете різної семантики, вам доведеться виконати додаткову роботу.

List< Integer > обхідний шлях

Рішення: Використовуйте Listз Integerоб'єктів ( List< Integer >) , а не масив примітивів ( int[]).

У цьому прикладі я створюю незмінний список не визначеного класу, використовуючи List.ofфункцію, додану до Java 9. Ви можете так само добре використовувати ArrayListдля модифікованого списку, підкріпленого масивом.

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

Обхід: СтворітьIntArrayклас та оберніть йогоint[].

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

Не ідеально, адже тепер вам доведеться дзвонити foo.getInts()замість foo.ints(), але все інше працює так, як вам хочеться.

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

Вихідні дані

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