Jak mogę bezpiecznie kopiować kolekcje?

W przeszłości mówiłem, aby bezpiecznie skopiować kolekcję i zrobić coś takiego:

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

lub

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

Ale czy te konstruktory „kopiujące”, podobne metody i strumienie tworzenia statycznego są naprawdę bezpieczne i gdzie określone są reguły? Rozumiem przez to, że podstawowe gwarancje integralności semantycznej oferowane przez język Java i kolekcje są wymuszane przeciwko złośliwemu rozmówcy, przy założeniu, że są uzasadnione SecurityManageri że nie ma żadnych wad.

Jestem zadowolony z metody rzucania ConcurrentModificationException, NullPointerException, IllegalArgumentException, ClassCastException, itd., A może nawet powieszenie.

StringJako przykład argumentu niezmiennego wybrałem . W przypadku tego pytania nie interesują mnie głębokie kopie kolekcji zmiennych typów, które mają swoje własne problemy.

(Żeby było jasne, przejrzałem kod źródłowy OpenJDK i mam jakąś odpowiedź na ArrayListi TreeSet.)

Nie ma prawdziwej ochrony przed celowo złośliwym kodem działającym w ramach tej samej maszyny JVM w zwykłych interfejsach API, takich jak Collection API.

Jak można łatwo wykazać:

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]

Jak widać, oczekiwanie, że List<String>nie zagwarantuje otrzymania listy Stringinstancji. Z powodu usuwania typów i typów surowych, nie jest nawet możliwa poprawka po stronie implementacji listy.

Inną rzeczą, za którą można winić ArrayListkonstruktora, jest zaufanie do toArrayimplementacji kolekcji przychodzącej . TreeMapnie wpływa to w ten sam sposób, ale tylko dlatego, że nie ma takiego wzrostu wydajności po przekazaniu tablicy, jak w konstrukcji an ArrayList. Żadna klasa nie gwarantuje ochrony w konstruktorze.

Zwykle nie ma sensu pisać kodu zakładającego celowo złośliwy kod za każdym rogiem. Jest zbyt wiele, co może zrobić, aby chronić się przed wszystkim. Taka ochrona jest użyteczna tylko dla kodu, który naprawdę zawiera w sobie akcję, która mogłaby dać szkodliwemu rozmówcy dostęp do czegoś, do czego nie byłaby w stanie uzyskać dostępu bez tego kodu.

Jeśli potrzebujesz bezpieczeństwa dla konkretnego kodu, użyj

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

Następnie możesz być pewien, że newStrszawiera on tylko łańcuchy i nie może zostać zmodyfikowany przez inny kod po jego zbudowaniu.

Lub użyj List<String> newStrs = List.of(strs.toArray(new String[0]));z Javą 9 lub nowszą
Zauważ, że Java 10 List.copyOf(strs)robi to samo, ale w jej dokumentacji nie stwierdzono, że nie można ufać toArraymetodzie kolekcji przychodzącej . Wywołanie List.of(…), które z pewnością utworzy kopię w przypadku, gdy zwróci listę opartą na tablicy, jest bezpieczniejsze.

Ponieważ żaden dzwoniący nie może zmienić sposobu, tablice działają, zrzucenie kolekcji przychodzącej do tablicy, a następnie zapełnienie jej nową kolekcją, zawsze zapewni bezpieczeństwo kopii. Ponieważ kolekcja może zawierać odniesienie do zwróconej tablicy, jak pokazano powyżej, może to zmienić podczas fazy kopiowania, ale nie może wpływać na kopię w kolekcji.

Tak więc wszelkie kontrole spójności powinny być wykonywane po pobraniu konkretnego elementu z tablicy lub w wynikowej kolekcji jako całości.

Wolę zostawić tę informację w komentarzu, ale nie mam wystarczającej reputacji, przepraszam :) Postaram się wtedy wyjaśnić tyle, ile potrafię.

Zamiast czegoś podobnego do constmodyfikatora używanego w C ++ do oznaczania funkcji składowych, które nie powinny modyfikować zawartości obiektu, w Javie pierwotnie zastosowano koncepcję „niezmienności”. Encapsulation (lub OCP, Open-Closed Principle) miał chronić przed wszelkimi nieoczekiwanymi mutacjami (zmianami) obiektu. Oczywiście API do refleksji to obchodzi; bezpośredni dostęp do pamięci robi to samo; to więcej o strzelaniu własną nogą :)

java.util.Collectionsam jest interfejsem zmiennym: ma addmetodę, która ma modyfikować kolekcję. Oczywiście programista może zawinąć kolekcję w coś, co rzuci ... i zdarzają się wszystkie wyjątki środowiska wykonawczego, ponieważ inny programista nie był w stanie odczytać javadoc, co wyraźnie mówi, że kolekcja jest niezmienna.

Zdecydowałem się użyć java.util.Iterabletypu, aby ujawnić niezmienną kolekcję w moich interfejsach. Semantycznie Iterablenie ma takiej cechy kolekcji, jak „zmienność”. Nadal będziesz (najprawdopodobniej) modyfikować bazowe kolekcje za pomocą strumieni.

java.util.Function<K,V>Można użyć JIC, aby eksponować mapy w niezmienny sposób ( getmetoda mapy pasuje do tej definicji)