ฉันจะคัดลอกคอลเลกชันอย่างปลอดภัยได้อย่างไร

ในอดีตฉันได้กล่าวว่าการคัดลอกคอลเลกชันอย่างปลอดภัยทำบางสิ่งเช่น:

public static void doThing(List<String> strs) {
    List<String> newStrs = new ArrayList<>(strs);

หรือ

public static void doThing(NavigableSet<String> strs) {
    NavigableSet<String> newStrs = new TreeSet<>(strs);

แต่ตัวสร้าง "สำเนา" เหล่านี้มีวิธีการสร้างและสตรีมแบบสแตติกที่คล้ายกันปลอดภัยจริงๆและมีการระบุกฎไว้ที่ไหนบ้าง โดยความปลอดภัยฉันหมายถึงการรับประกันความสมบูรณ์แบบพื้นฐานทางความหมายของภาษาจาวาและคอลเลกชันที่บังคับใช้กับผู้โทรที่เป็นอันตรายโดยสมมติว่าได้รับการสนับสนุนจากเหตุผลที่สมเหตุสมผลSecurityManagerและไม่มีข้อบกพร่องใด ๆ

ฉันมีความสุขด้วยวิธีการขว้างปาConcurrentModificationException, NullPointerException, IllegalArgumentException, ClassCastExceptionฯลฯ หรือบางทีอาจจะแขวน

ฉันได้เลือกStringเป็นตัวอย่างของการโต้แย้งประเภทไม่เปลี่ยนรูป สำหรับคำถามนี้ฉันไม่สนใจสำเนาชุดลึกสำหรับคอลเล็กชั่นที่ไม่แน่นอนซึ่งมี gotchas ของตัวเอง

(เพื่อความชัดเจนฉันได้ดูซอร์สโค้ด OpenJDK และมีคำตอบบางอย่างสำหรับArrayListและTreeSet.)

ไม่มีการป้องกันที่แท้จริงสำหรับโค้ดที่ประสงค์ร้ายที่ทำงานอยู่ภายใน JVM เดียวกันใน API ทั่วไปเช่น API การรวบรวม

สามารถแสดงให้เห็นได้อย่างง่ายดาย:

public static void main(String[] args) throws InterruptedException {
    Object[] array = { "foo", "bar", "baz", "and", "another", "string" };
    array[array.length - 1] = new Object() {
        @Override
        public String toString() {
            Collections.shuffle(Arrays.asList(array));
            return "string";
        }
    };
    doThing(new ArrayList<String>() {
        @Override public Object[] toArray() {
            return array;
        }
    });
}

public static void doThing(List<String> strs) {
    List<String> newStrs = new ArrayList<>(strs);

    System.out.println("made a safe copy " + newStrs);
    for(int i = 0; i < 10; i++) {
        System.out.println(newStrs);
    }
}

made a safe copy [foo, bar, baz, and, another, string]
[bar, and, string, string, another, foo]
[and, baz, bar, string, string, string]
[another, baz, and, foo, bar, string]
[another, bar, and, foo, string, and]
[another, baz, string, another, and, foo]
[string, and, another, foo, string, foo]
[baz, string, foo, and, baz, string]
[bar, another, string, and, another, baz]
[bar, string, foo, string, baz, and]
[bar, string, bar, another, and, foo]

อย่างที่คุณเห็นการคาดหวังว่าList<String>จะไม่รับประกันว่าจะได้รับรายชื่อStringอินสแตนซ์ เนื่องจากการลบประเภทและประเภทดิบจึงไม่มีแม้แต่การแก้ไขในด้านการใช้งานรายการ

สิ่งอื่น ๆ ที่คุณสามารถตำหนิArrayListคอนสตรัค 's สำหรับความไว้วางใจในการเก็บสะสมเข้ามาของtoArrayการดำเนินงาน TreeMapไม่ได้รับผลกระทบในทางเดียวกัน ArrayListแต่เพียงเพราะไม่มีกำไรจากผลการดำเนินงานดังกล่าวจากการส่งผ่านอาร์เรย์เช่นในการก่อสร้างนั้น คลาสทั้งสองไม่รับประกันการป้องกันในตัวสร้าง

โดยปกติแล้วจะไม่มีประเด็นในการพยายามเขียนโค้ดโดยสมมติว่ามีรหัสที่เป็นอันตรายรอบ ๆ มุม มีมากเกินไปที่จะทำเพื่อปกป้องทุกสิ่ง การป้องกันดังกล่าวมีประโยชน์เฉพาะกับรหัสที่ทำในแค็ปซูลการกระทำที่อาจทำให้ผู้เรียกที่เป็นอันตรายสามารถเข้าถึงบางสิ่งได้ แต่ไม่สามารถเข้าถึงได้หากไม่มีรหัสนี้

หากคุณต้องการความปลอดภัยสำหรับรหัสเฉพาะให้ใช้

public static void doThing(List<String> strs) {
    String[] content = strs.toArray(new String[0]);
    List<String> newStrs = new ArrayList<>(Arrays.asList(content));

    System.out.println("made a safe copy " + newStrs);
    for(int i = 0; i < 10; i++) {
        System.out.println(newStrs);
    }
}

จากนั้นคุณสามารถมั่นใจได้ว่าnewStrsจะมีเพียงสตริงและไม่สามารถแก้ไขได้โดยรหัสอื่นหลังจากการสร้าง

หรือใช้List<String> newStrs = List.of(strs.toArray(new String[0]));กับ Java 9 หรือใหม่กว่า
โปรดทราบว่า Java 10 นั้นList.copyOf(strs)ทำเหมือนกัน แต่เอกสารของมันไม่ได้ระบุว่ารับประกันว่าจะไม่เชื่อถือtoArrayวิธีการรวบรวมข้อมูลที่เข้ามา ดังนั้นการโทรList.of(…)ซึ่งจะทำสำเนาอย่างแน่นอนในกรณีที่ส่งคืนรายการตามอาเรย์นั้นปลอดภัยกว่า

เนื่องจากผู้โทรไม่สามารถเปลี่ยนแปลงวิธีการทำงานได้อาร์เรย์การทิ้งคอลเล็กชันขาเข้าลงในอาร์เรย์แล้วตามด้วยการเติมคอลเล็กชันใหม่ด้วยจะทำให้การคัดลอกปลอดภัยเสมอ เนื่องจากคอลเลกชันสามารถเก็บการอ้างอิงไปยังอาร์เรย์ที่ส่งคืนตามที่แสดงไว้ด้านบนมันจึงสามารถเปลี่ยนแปลงได้ในระหว่างขั้นตอนการคัดลอก แต่จะไม่ส่งผลกระทบต่อการคัดลอกในคอลเลกชัน

ดังนั้นการตรวจสอบความสอดคล้องใด ๆ ควรทำหลังจากองค์ประกอบเฉพาะถูกดึงออกมาจากอาร์เรย์หรือในการรวบรวมผลลัพธ์โดยรวม

ฉันอยากจะทิ้งข้อมูลนี้ไว้ในความคิดเห็น แต่ฉันไม่มีชื่อเสียงพอขอโทษ :) ฉันจะพยายามอธิบายให้มากที่สุดเท่าที่จะทำได้

แทนที่จะเป็นบางสิ่งอย่างเช่นโมดิconstฟายเออร์ที่ใช้ใน C ++ เพื่อทำเครื่องหมายฟังก์ชั่นสมาชิกที่ไม่ควรแก้ไขเนื้อหาของวัตถุ แต่เดิมทีใน Java นั้นใช้แนวคิดของ "การไม่เปลี่ยนแปลง" Encapsulation (หรือ OCP, Open-Closed Principle) ควรที่จะป้องกันการกลายพันธุ์ (การเปลี่ยนแปลง) ของวัตถุที่ไม่คาดคิด แน่นอนว่าการสะท้อน API นั้นเดินไปรอบ ๆ การเข้าถึงหน่วยความจำโดยตรงไม่เหมือนกัน; นั่นเป็นเรื่องของการยิงขาของตัวเอง :)

java.util.Collectionตัวเองเป็นอินเตอร์เฟซที่ไม่แน่นอน: มันมีaddวิธีการที่ควรจะแก้ไขการเก็บรวบรวม แน่นอนว่าโปรแกรมเมอร์อาจห่อรวบรวมสิ่งที่จะโยน ... และข้อยกเว้นรันไทม์ทั้งหมดจะเกิดขึ้นเพราะโปรแกรมเมอร์คนอื่นไม่สามารถอ่าน javadoc ซึ่งเห็นได้ชัดว่าคอลเลกชันนั้นไม่เปลี่ยนรูป

ฉันตัดสินใจใช้java.util.Iterabletype เพื่อแสดงการรวบรวมที่ไม่เปลี่ยนแปลงในอินเตอร์เฟสของฉัน ความหมายIterableไม่มีลักษณะของการรวบรวมว่า "ไม่แน่นอน" ยังคุณจะ (ส่วนใหญ่) จะสามารถปรับเปลี่ยนคอลเลกชันพื้นฐานผ่านสตรีม

JIC เพื่อแสดงแผนที่ในลักษณะที่ไม่เปลี่ยนรูปแบบjava.util.Function<K,V>สามารถใช้ ( getวิธีของแผนที่ตรงกับคำจำกัดความนี้)