Использование итератора в TreeSet

Если вы добавите элемент во время итерации, ваш следующий вызов итератора, скорее всего, вызовет ошибку ConcurrentModificationException. См. отказоустойчивое поведение в документах TreeSet.

Чтобы повторить и добавить элементы, вы можете сначала скопировать их в другой набор:

TreeSet<Custom> ts = ...
TreeSet<Custom> tsWithExtra = new TreeSet(ts);

for (Custom c : ts) {
  // possibly add to tsWithExtra
}

// continue, using tsWithExtra

или создайте отдельную коллекцию, которая будет объединена с ts после итерации, как предлагает Колин.

Вы получите java.util.ConcurrentModificationException, если добавите элемент в TreeSet внутри цикла while.

Set<String> ts=new TreeSet<String>();
ts.addAll(Arrays.asList(new String[]{"abb", "abd", "abg"}));
Iterator<String> itr=ts.iterator();
while(itr.hasNext()){
    String s = itr.next();
    System.out.println("s: " + s);
    if (s.equals("abd"))
        ts.add("abc");
}

Выход

Exception in thread "main" java.util.ConcurrentModificationException

public static void main(String[] args) {
    TreeSet<Integer> ts=new TreeSet<Integer>();
    ts.add(2);
    ts.add(4);
    ts.add(0);

    Iterator<Integer> itr=ts.iterator();
    while(itr.hasNext()){
        Integer c=itr.next();
        System.out.println(c);
        //Code
        ts.add(1);
    }
}


Exception in thread "main" java.util.ConcurrentModificationException

Это относится ко всем коллекциям, таким как List, Map, Set, потому что при запуске итератора он может быть заблокирован.

если вы перебираете список с помощью итератора, это исключение придет. Я думаю, что в противном случае этот цикл будет бесконечным, поскольку вы добавляете элемент целиком.

Рассмотрим без итератора:

public static void main(String[] args) {
    List<Integer> list=new ArrayList<Integer>();
    list.add(2);
    list.add(4);
    list.add(0);

    for (int i = 0; i < 3; i++) {
        System.out.println(list.get(i));
        list.add(3);
    }
    System.out.println("Size" +list.size());
}

это будет хорошо.

Чтобы избежать ConcurrentModificationException, вы можете проверить мой UpdateableTreeSet. Я даже добавил новый тестовый пример, показывающий, как добавлять элементы во время цикла. Точнее, вы помечаете новые элементы для более позднего отложенного обновления набора. Это работает очень хорошо. В основном вы делаете что-то вроде

for (MyComparableElement element : myUpdateableTreeSet) {
    if (someCondition) {
        // Add new element (deferred)
        myUpdateableTreeSet.markForUpdate(
            new MyComparableElement("foo", "bar", 1, 2)
        );
    }
}

// Perform bulk update
myUpdateableTreeSet.updateMarked();

Думаю, это именно то, что вам нужно. :-)

Чтобы предотвратить ConcurrentModificationException во время ходьбы. Ниже приведена моя версия, разрешающая высокочастотную вставку в TreeSet() и позволяющая одновременно выполнять итерацию. Этот класс использует дополнительную очередь для хранения вставляемого объекта во время итерации TreeSet.

public class UpdatableTransactionSet {
TreeSet <DepKey> transactions = new TreeSet <DepKey> ();
LinkedList <DepKey> queue = new LinkedList <DepKey> ();
boolean busy=false;
/**
 * directly call it
 * @param e
 */
void add(DepKey e) {
    boolean bb = getLock();
    if(bb) {
        transactions.add(e);
        freeLock();
    } else {
        synchronized(queue) {
            queue.add(e);
        }
    }
}
/**
 * must getLock() and freeLock() while call this getIterator function
 * @return
 */
Iterator<DepKey> getIterator() {
    return null;
}

synchronized boolean getLock() {
    if(busy) return false;
    busy = true;
    return true;
}
synchronized void freeLock() {
    synchronized(queue) {
        for(DepKey e:queue) {
            transactions.add(e);
        }
    }       
    busy = false;
}
}

Хотя на этот вопрос уже дан ответ, я думаю, что наиболее удовлетворительный ответ содержится в javadoc самого TreeSet

Итераторы, возвращаемые методом итератора этого класса, являются отказоустойчивыми: если набор изменяется в любое время после создания итератора любым способом, кроме как с помощью собственного метода удаления итератора, итератор выдает исключение ConcurrentModificationException. Таким образом, перед лицом одновременной модификации итератор быстро и чисто дает сбой, а не рискует произвольным, недетерминированным поведением в неопределенное время в будущем.

Обратите внимание, что отказоустойчивое поведение итератора не может быть гарантировано, так как, вообще говоря, невозможно дать какие-либо жесткие гарантии при наличии несинхронизированной параллельной модификации. Отказоустойчивые итераторы генерируют исключение ConcurrentModificationException в максимально возможной степени. Поэтому было бы неправильно писать программу, корректность которой зависела бы от этого исключения: безотказное поведение итераторов следует использовать только для обнаружения ошибок.

Чтобы избежать ошибки параллельной модификации, которая неизбежно возникает при вставке, вы также можете создать временную копию набора, вместо этого выполнить итерацию по копии и изменить оригинал.