Utilisation de l'itérateur sur un TreeSet

SITUATION: j'ai un TreeSet d'Objets personnalisés, et j'ai également personnalisé le Comparateur. J'ai créé un itérateur sur ce TreeSet. 

TreeSet<Custom> ts=new TreeSet<Custom>();
Iterator<Custom> itr=ts.iterator();
while(itr.hasNext()){
    Custom c=itr.next();
    //Code to add a new element to the TreeSet ts
}

QUESTION: eh Bien, je veux savoir que si j'ajoute un nouvel élément à la TreeSet à l'intérieur de la boucle while, alors que nouvel élément de rentrer dans l'ordre immédiatement. En d'autres termes, si j'ajoute un nouvel élément à l'intérieur de la boucle while et il est moins cher que celui que je suis en train de portefeuille en c, puis dans la prochaine itération vais-je obtenir le même élément de c, comme dans la dernière itération?(car après le tri, le nouvel élément qui va occuper une place quelque part avant de l'élément courant).

source d'informationauteur aps | 2011-06-23

  1. 22

    Si vous ajoutez un élément au cours de votre tour, votre prochaine itérateur appel sera probablement jeter un ConcurrentModificationException. Voir le fail-fast comportement dans TreeSet docs.

    À parcourir et ajouter des éléments, vous pouvez copier à un autre jeu:

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

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

//continue, using tsWithExtra

    ou de créer une collection à part à être fusionné avec ts après itération, comme Colin suggère.

  2. 6

    Vous obtiendrez un java.util.ConcurrentModificationException si vous ajoutez un élément dans le TreeSet à l'intérieur de la boucle 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");
}

    De sortie

    Exception in thread "main" java.util.ConcurrentModificationException
  3. 3
    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

    Pour toutes les collections, comme List , Map , Set
    Parce que quand itérateur commence, il peut être mettre un peu de verrouillage .

    si vous parcourez la liste à l'aide de itérateur puis cette exception va venir. Je pense que sinon cette boucle sera infinie que vous ajoutez l'élément de l'ensemble de l'itération.

    Envisager sans un itérateur: 

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

    ce sera très bien .

  4. 1

    Afin d'éviter la ConcurrentModificationException vous voudrez peut-être consulter mon UpdateableTreeSet. J'ai même ajouté un nouveau cas de test montrant comment ajouter des éléments au cours d'une boucle. Pour être plus exact, vous marquez de nouveaux éléments pour plus tard, l'ajournement de la mise à jour de l'ensemble. Cela fonctionne très bien. Fondamentalement, vous faites quelque chose comme

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

//Perform bulk update
myUpdateableTreeSet.updateMarked();

    Je suppose que c'est très exactement ce dont vous avez besoin. :-)

  5. 0

    Pour empêcher la ConcurrentModificationException lors de la marche.
    Voici ma version de permettre à la haute fréquence de l'insertion dans le TreeSet() et permettre simultanément itérer sur elle. Cette classe d'utiliser un supplément de file d'attente pour stocker l'insertion de l'objet lors de la TreeSet est en cours d'itération.

    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;
}
}
  6. 0

    Alors que la question a déjà été répondu, je pense que le plus satisfaisant réponse se trouve dans javadoc de TreeSet lui-même

    Les itérateurs retourné par cette classe iterator de méthode sont fail-fast: si la valeur est modifiée à tout moment après l'itérateur est créé, en aucune façon, sauf par le biais de l'itérateur propre méthode remove, l'itérateur va jeter un ConcurrentModificationException. Ainsi, dans le visage de modifications simultanées, l'itérateur échoue rapidement et proprement, plutôt que de risquer d'arbitraire, un comportement non déterministe en un temps indéterminé dans l'avenir.

    Noter que le fail-fast comportement d'un itérateur ne peut pas être garanti car il est, >en général, impossible de faire tout dur garanties en présence de désynchroniser les modifications simultanées. Fail-fast itérateurs jeter ConcurrentModificationException sur une base du meilleur effort. Par conséquent, il serait faux d'écrire un programme qui dépendait de cette exception par sa justesse: le fail-fast comportement des itérateurs doit uniquement être utilisée pour détecter les bugs.

  7. 0

    Pour éviter les modifications simultanées d'erreur lié à se produire lorsque vous êtes en train de faire de l'insertion, vous pouvez également créer une copie temporaire de l'Ensemble, itérer sur la copie au lieu de cela, et de modifier l'original.