Aşağıdaki kod verildiğinde:

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
}

O dizinin, belli ki, görünüyor toString, equalsyöntemler (yerine statik yöntemler kullanılır Arrays::equals, Arrays::deepEquals ya da Array::toString).

Yani Java 14 Kayıtları ( JEP 359 ) dizilerle çok iyi çalışmıyor, ilgili yöntemlerin bir IDE (en azından IntelliJ'de, varsayılan olarak "yararlı" yöntemler üreten, yani statik yöntemleri kullandıkları bir IDE ile oluşturulması gerekir içinde Arrays).

Yoksa başka bir çözüm var mı?

Java dizileri kayıtlar için çeşitli zorluklar yaratır ve bunlar tasarıma bir takım kısıtlamalar ekler. Diziler değiştirilebilir ve eşitlik semantikleri (Object'den miras alınan) içerikle değil kimlikle ilgilidir.

Örneğinizin temel sorunu equals()dizilerde referans eşitliği değil, içerik eşitliği olmasını istemenizdir . equals()Kayıtlar için (varsayılan) semantik , bileşenlerin eşitliğine dayanır; senin örnekte, iki Fooayrı dizileri içeren kayıtlar vardır farklı ve kayıt düzgün davranıyor. Sorun şu ki, sadece eşitlik karşılaştırması farklı olsaydı.

Bununla birlikte, istediğiniz semantikle bir kayıt beyan edebilirsiniz, sadece daha fazla iş gerektirir ve çok fazla iş olduğunu hissedebilirsiniz. İşte istediğinizi yapan bir kayıt:

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

Bunun yaptığı şey, (kurucuda) ve çıkış yolunda (erişimci içinde) ve aynı zamanda dizinin içeriğini kullanmak için eşitlik semantiğini ayarlayan savunma kopyasıdır. Bu, üst sınıfta gerekli java.lang.Recordolan "bileşenlerine bir kayıt ayırmak ve bileşenleri yeni bir kayda yeniden yapılandırmak", eşit bir kayıt sağlayan " değişmezi destekler ."

"Ama bu çok fazla iş, kayıtları kullanmak istedim, bu yüzden hepsini yazmak zorunda kalmadım" diyebilirsiniz. Ancak, kayıtlar temel olarak sözdizimsel bir araç değildir (sözdizimsel olarak daha hoş olsalar da), semantik bir araçtır: kayıtlar nominal tupllerdir . Çoğu zaman, kompakt sözdizimi de istenen semantiği verir, ancak farklı semantikler istiyorsanız, biraz fazladan iş yapmanız gerekir.

List< Integer > geçici çözüm

Çözüm: kullanın Listve Integernesne ( List< Integer >) yerine ilkel dizisi ( int[]).

Bu örnekte, Java 9'a eklenen özelliği kullanarak değiştirilemeyen bir sınıf değiştirilmemiş listesini somutlaştırıyorum . Bir dizi tarafından desteklenen değiştirilebilir bir liste için List.ofde kullanabilirsiniz 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
    }
}

Geçici çözüm: BirIntArraysınıfoluşturunveint[].

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

Mükemmel değil, çünkü şimdi foo.getInts()yerine aramak zorundasınız foo.ints(), ancak diğer her şey istediğiniz gibi çalışıyor.

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

Çıktı

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