Diberikan kode berikut:

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
}

Tampaknya, jelas bahwa array toString, equalsmetode digunakan (bukan metode statis Arrays::equals,, Arrays::deepEquals atau Array::toString).

Jadi saya kira Java 14 Records ( JEP 359 ) tidak berfungsi dengan baik dengan array, metode masing-masing harus dihasilkan dengan IDE (yang setidaknya di IntelliJ, secara default menghasilkan metode "berguna", yaitu mereka menggunakan metode statis dalam Arrays).

Atau adakah solusi lain?

Array Java menimbulkan beberapa tantangan untuk rekaman, dan ini menambah sejumlah kendala pada desain. Array bisa berubah, dan semantik kesetaraan mereka (diwarisi dari Object) adalah dengan identitas, bukan konten.

Masalah mendasar dengan contoh Anda adalah bahwa Anda berharap bahwa equals()pada array berarti kesetaraan konten, bukan kesetaraan referensi. Semantik (default) equals()untuk catatan didasarkan pada kesetaraan komponen; dalam contoh, dua Foocatatan yang berisi array yang berbeda yang berbeda, dan catatan berperilaku dengan benar. Masalahnya adalah Anda hanya berharap perbandingan kesetaraannya berbeda.

Yang mengatakan, Anda dapat mendeklarasikan catatan dengan semantik yang Anda inginkan, itu hanya membutuhkan lebih banyak pekerjaan, dan Anda mungkin merasa terlalu banyak bekerja. Berikut catatan yang melakukan apa yang Anda inginkan:

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

Apa yang dilakukan adalah salinan defensif di jalan (di konstruktor) dan di jalan keluar (di accessor), serta menyesuaikan semantik kesetaraan untuk menggunakan konten array. Ini mendukung invarian, diperlukan dalam superclass java.lang.Record, yang "memisahkan catatan ke dalam komponennya, dan merekonstruksi komponen menjadi catatan baru, menghasilkan rekor yang sama."

Anda mungkin berkata, "Tapi itu terlalu banyak pekerjaan, saya ingin menggunakan catatan sehingga saya tidak perlu mengetik semua itu." Tetapi, catatan bukan terutama alat sintaksis (meskipun secara sintaksis lebih menyenangkan), catatan adalah alat semantik: catatan adalah tupel nominal . Sebagian besar waktu, sintaks kompak juga menghasilkan semantik yang diinginkan, tetapi jika Anda ingin semantik yang berbeda, Anda harus melakukan beberapa pekerjaan tambahan.

List< Integer > solusi

Penanganan Masalah: Gunakan a Listdari Integerobjek ( List< Integer >) daripada array primitif ( int[]).

Dalam contoh ini, saya instantiate daftar kelas yang tidak ditentukan yang tidak dapat dimodifikasi dengan menggunakan List.offitur yang ditambahkan ke Java 9. Anda bisa juga menggunakan ArrayList, untuk daftar yang dapat dimodifikasi yang didukung oleh array.

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

Penanganan masalah: BuatIntArraykelas dan bungkusint[].

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

Tidak sempurna, karena Anda sekarang harus menelepon foo.getInts()alih-alih foo.ints(), tetapi semua yang lain berfungsi seperti yang Anda inginkan.

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

Keluaran

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