Java - HashSet meilleure façon d'implémenter itérateur qui ne supporte pas remove()

Question

J'ai une classe qui utilise un HashSet et je veux que la classe implémente Iterable, mais je ne veux pas, cependant, que l'itérateur de classe supporte la méthode remove().

L'itérateur par défaut de HashSet est HashSet.KeyIterator qui est une classe privée dans la classe HashSet, donc je ne peux pas simplement l'étendre et redéfinir la méthode remove.

Idéalement, je voudrais éviter d'écrire une classe wrapper pour KeyIterator, mais je ne sais pas comment je pourrais facilement et simplement implémenter mon propre itérateur d'une autre manière.

Des idées?

Cheers,

Pete

Answer 1

java.util.Collections.unmodifiableSet(myHashSet).iterator(); 

Answer 2

Si vous utilisez Apache Commons Collections, vous pouvez utiliser org.apache.commons.collections.iterators.UnmodifiableIterator :

UnmodifiableIterator.decorate(set.iterator()); 

Goyave (Google Collections) a également un UnmodifiableIterator, qui supports génériques: com.google.common.collect.UnmodifiableIterator<E> Utilisation:

Iterators.unmodifiableIterator(set.iterator()); 

Answer 3

Utilisez le Composite pattern: créer une nouvelle implémentation de l'interface Iterator qui est une enveloppe autour de la iterator du HashSet, mais au lieu de passer par des appels à remove jeter un UnsupportedOperationException.

Answer 4

Création de l'emballage en utilisant une classe interne anonyme est assez simple:

Voir cet exemple:

package some; 
import java.util.Set; 
import java.util.HashSet; 
import java.util.Iterator; 

class MyIterable<E> implements Iterable<E> { 
    private Set<E> internalSet = new HashSet<E>(); 

    public MyIterable(E ... all) { 
     for(E e : all){ 
      internalSet.add(e); 
     } 
    } 

    public Iterator<E> iterator() { 
     final Iterator<E> i = internalSet.iterator(); 
     return new Iterator<E>() { 
      public boolean hasNext(){ 
       return i.hasNext(); 
      } 
      public E next(){ 
       return i.next(); 
      } 
      public void remove(){ 
       //you may throw new UnsupportedOperationException(); 
      } 
     }; 
    } 

    // Test it 
    public static void main(String [] args) { 
     Iterable<String> iterable = new MyIterable<String>("a", "b", "a", "b"); 

     System.out.println("Trying to invoke: remove"); 
     for(Iterator<String> iterator = iterable.iterator(); 
             iterator.hasNext(); 
             iterator.remove()){ 
       System.out.println(iterator.next()); 
     } 
     System.out.println("Used in foreach"); 
     for(String s : iterable){ 
      System.out.println(s); 
     } 

    } 
} 

Vous pouvez également jeter UnsupportedOperationException si vous voulez déclarer explicitement que l'opération ne soit pas pris en charge, mais C'est peut-être un peu excessif.

Answer 5

ci-dessous est une façon que nous pouvons éviter ce genre d'exceptions tout en supprimant les éléments du iterator

List<String> results=new ArrayList<String>() //a collection 
Iterator<String> itr=results.iterator(); 
List<String> toBeRemoved=new ArrayList<String>(); 

while(itr.hasNext()){ 
    if(condiation){ 
     tobeRemoved.add(itr.next); 

    } 
} 
//now we can remove unnecessary elements form the iterator 
results.removeAll(toBeRemoved); 

Ce genre de mise en oeuvre est garantie qu'aucune exception à la modification iterator