Koleksiyonları güvenli bir şekilde nasıl kopyalayabilirim?

Geçmişte, bir koleksiyonu güvenli bir şekilde kopyalamayı şöyle söyledim:

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

veya

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

Ancak bu "kopya" kurucuları, benzer statik oluşturma yöntemleri ve akışları gerçekten güvenli midir ve kurallar nerede belirtilmiştir? Güvenli bir şekilde , Java dili tarafından sunulan temel anlamsal bütünlük garantileri ve makul bir kişi tarafından desteklenen SecurityManagerve kusurların olmadığı varsayılarak kötü amaçlı bir arayan için uygulanan koleksiyonlar vardır.

Ben metod atma mutluyum ConcurrentModificationException, NullPointerException, IllegalArgumentException, ClassCastException, vb hatta belki asılı.

StringDeğişmez tipte bir argüman örneği olarak seçtim . Bu soru için, kendi gotcha'ları olan değişebilir tiplerin koleksiyonları için derin kopyalarla ilgilenmiyorum.

(Açık olmak gerekirse, ben OpenJDK kaynak koduna bakıp için cevap çeşit var ArrayListve TreeSet.)

Koleksiyon API'si gibi sıradan API'larda aynı JVM içinde çalışan kasıtlı olarak kötü amaçlı koda karşı gerçek bir koruma yoktur.

Kolayca gösterilebileceği gibi:

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]

Gördüğünüz gibi, bir beklemek List<String>aslında bir Stringörnek listesi almayı garanti etmez . Tür silme ve ham türler nedeniyle, liste uygulama tarafında bir düzeltme bile mümkün değildir.

Yapıcısını suçlayabileceğiniz bir diğer şey ArrayListde, gelen koleksiyonun toArrayuygulanmasına duyulan güvendir . TreeMapaynı şekilde etkilenmez, ancak bir dizinin yapımında olduğu gibi, diziyi geçmekten böyle bir performans kazancı olmadığı için ArrayList. Her iki sınıf da yapıcıda bir korumayı garanti etmez.

Normalde, her köşede kasıtlı olarak kötü amaçlı kod olduğunu varsayarak kod yazmaya çalışmanın bir anlamı yoktur. Her şeye karşı korumak için yapabileceği çok şey var. Bu tür bir koruma, yalnızca kötü niyetli bir kişinin bir şeye erişmesine neden olabilecek bir eylemi gerçekten içine alan, bu kod olmadan erişemeyen kod için kullanışlıdır.

Belirli bir kod için güvenliğe ihtiyacınız varsa,

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

Ardından, newStrsyalnızca dizeler içerdiğinden ve yapıldıktan sonra diğer kodlarla değiştirilemeyeceğinden emin olabilirsiniz.

Veya List<String> newStrs = List.of(strs.toArray(new String[0]));Java 9 veya daha yeni bir sürümle kullanın Java
10'ların List.copyOf(strs)aynı şeyi yaptığını unutmayın, ancak belgelerinde gelen koleksiyonun toArrayyöntemine güvenmediği garanti edilmez . Bu nedenle List.of(…), dizi tabanlı bir liste döndürmesi durumunda kesinlikle bir kopya yapacak olan arama yapmak daha güvenlidir.

Hiçbir arayan yolu değiştiremediğinden, diziler çalışır, gelen koleksiyonu bir diziye döker ve ardından yeni koleksiyonu onunla doldurur, her zaman kopyayı güvenli hale getirir. Koleksiyon, yukarıda gösterildiği gibi döndürülen diziye bir başvuru taşıyabildiğinden, kopyalama aşamasında bu diziyi değiştirebilir, ancak koleksiyondaki kopyayı etkileyemez.

Bu nedenle, herhangi bir tutarlılık kontrolü, belirli bir eleman diziden veya bir bütün olarak ortaya çıkan koleksiyonda alındıktan sonra yapılmalıdır.

Bu bilgiyi yorumda bırakmayı tercih ederim, ama yeterince üne sahip değilim, üzgünüm :) O zaman yapabildiğim kadar ayrıntılı anlatmaya çalışacağım.

constNesne içeriğini değiştirmesi gerekmeyen üye işlevlerini işaretlemek için C ++ 'da kullanılan değiştirici gibi bir şey yerine, Java'da başlangıçta "değişmezlik" kavramı kullanılmıştır. Kapsülleme (veya OCP, Açık-Kapalı Prensibi) bir nesnenin beklenmedik mutasyonlarına (değişikliklerine) karşı koruma sağlamalıdır. Elbette yansıma API'sı bu konuda yürüyor; doğrudan bellek erişimi aynı şeyi yapar; Bu daha çok kendi bacağını vurmakla ilgili :)

java.util.Collectionkendisi değiştirilebilir bir arayüzdür: addkoleksiyonu değiştirmesi gereken bir yöntemi vardır. Tabii ki programcı koleksiyonu atacak bir şeye sarabilir ... ve tüm çalışma zamanı istisnaları gerçekleşir çünkü başka bir programcı koleksiyonun değişmez olduğunu açıkça söyleyen javadoc'u okuyamadı.

java.util.IterableArabirimlerimdeki değişmez koleksiyonu göstermek için yazı tipini kullanmaya karar verdim . Anlamsal Iterableolarak "değişebilirlik" gibi bir toplama özelliği yoktur. Yine de (büyük olasılıkla) altta yatan koleksiyonları akışlar aracılığıyla değiştirebileceksiniz.

JIC, haritaları değişmez bir şekilde ortaya çıkarmak java.util.Function<K,V>için kullanılabilir (haritanın getyöntemi bu tanıma uyar)