รับรหัสต่อไปนี้:

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 Records ( 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ว่า "การแยกเร็กคอร์ดออกเป็นส่วนประกอบของมันและการสร้างส่วนประกอบใหม่ในเร็กคอร์ดใหม่ให้ผลการบันทึกที่เท่าเทียมกัน"

คุณอาจพูดว่า "แต่มันใช้งานได้มากเกินไปฉันต้องการใช้บันทึกดังนั้นฉันจึงไม่ต้องพิมพ์ทุกอย่าง" แต่ไม่ได้บันทึกหลักเครื่องมือประโยค (แม้ว่าพวกเขาจะ syntactically สบายมากขึ้น) พวกเขาเป็นเครื่องมือที่มีความหมาย: บันทึกเป็นtuples เล็กน้อย ส่วนใหญ่แล้วซินแท็กซ์คอมแพคจะให้ความหมายที่ต้องการ แต่ถ้าคุณต้องการซีแมนทิกส์ต่างกันคุณต้องทำงานพิเศษบางอย่าง

List< Integer > วิธีแก้ปัญหา

การแก้ปัญหา: ใช้ListของIntegerวัตถุ ( List< Integer >) มากกว่าอาร์เรย์ของ primitives ( 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
    }
}

การแก้ปัญหา:การสร้างการเรียนและห่อIntArrayint[]

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