Учитывая следующий код:

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