Як я можу безпечно копіювати колекції?

Раніше я казав, що безпечно копіювати колекцію, роблячи щось на кшталт:

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

Але чи справді ці "копіюючі" конструктори, подібні статичні методи створення та потоки, справді безпечні та де вказані правила? Під безпечним я маю на увазі основні гарантії семантичної цілісності, пропоновані мовою Java та колекціями, застосовані проти зловмисного абонента, якщо вважати, що вони підкріплені розумним SecurityManagerі що немає недоліків.

Я задоволений метод метання ConcurrentModificationException, NullPointerException, IllegalArgumentException, ClassCastExceptionі т.д., або , можливо , навіть висить.

Я обрав Stringяк приклад аргумент непорушного типу. З цього питання мене не цікавлять глибокі копії для колекцій змінних типів, у яких є свої ґетчі.

(Щоб було зрозуміло, я подивився вихідний код OpenJDK і маю якусь відповідь на ArrayListі TreeSet.)

Немає реального захисту від навмисно зловмисного коду, що працює в межах одного JVM у звичайних API, як 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конструктора, - це довіра до реалізації вхідної колекції 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 спочатку було використано поняття "незмінність". Інкапсуляція (або OCP, відкритий закритий принцип) повинна була захищати від будь-яких несподіваних мутацій (змін) об'єкта. Звичайно, API роздумів обходить це; прямий доступ до пам'яті робить те саме; це більше про відстріл власною ногою :)

java.util.CollectionСам по собі є змінним інтерфейсом: він має addметод, який повинен модифікувати колекцію. Звичайно, програміст може перетворити колекцію на щось, що кине ... і всі винятки з виконання будуть відбуватися, оскільки інший програміст не зміг прочитати javadoc, що чітко говорить, що колекція незмінна.

Я вирішив використовувати java.util.Iterableтип, щоб викрити незмінну колекцію в своїх інтерфейсах. Семантично Iterableне має такої характеристики колекції, як «мутабельність». Тим не менш, ви (швидше за все) зможете змінювати основні колекції за допомогою потоків.

JIC, для викриття карт незмінним способом java.util.Function<K,V>можна використовувати ( getметод карти відповідає цьому визначенню)