HashSet.supprimer () et itérateur.remove() ne fonctionne pas

Sous les couvertures, HashSet utilise HashMap, qui appelle HashMap.removeEntryForKey (objet) lorsque L'un ou L'autre HashSet.supprimer (objet) ou itérateur.remove() est appelé. Cette méthode utilise à la fois hashCode () et equals () pour valider qu'elle supprime l'objet approprié de la collection.

Si les deux itérateurs.supprimer () et HashSet.remove (Object) ne fonctionne pas, alors quelque chose ne va pas avec vos méthodes equals () ou hashCode (). L'affichage du code pour ceux-ci serait utile dans le diagnostic de votre question.

Êtes-vous absolument certain que DataResult est immuable? Quel est le type de l'horodatage? Si c'est un java.util.Date en faites-vous des copies lorsque vous initialisez le DataResult? Gardez à l'esprit que java.util.Date est mutable.

Par exemple:

Date timestamp = new Date();
DataResult d = new DataResult(timestamp);
System.out.println(d.getTimestamp());
timestamp.setTime(System.currentTimeMillis());
System.out.println(d.getTimestamp());

Imprimerait deux fois différentes.

Cela aiderait aussi si vous pouviez poster du code source.

Merci pour toute l'aide. Je soupçonne que le problème doit être avec equals() et hashCode() comme suggéré par spencerk. J'ai vérifié ceux dans mon Débogueur et avec des tests unitaires, mais je dois manquer quelque chose.

J'ai fini par faire une solution de contournement-copier tous les éléments sauf un dans un nouvel ensemble. Pour les coups de pied, J'ai utilisé Apache Commons CollectionUtils.

    Set<DataResult> tempResults = new HashSet<DataResult>();
    CollectionUtils.select(allResults, 
            new Predicate()
            {
                public boolean evaluate(Object oldData)
                {
                    return !data.equalsData((DataResult) oldData);
                }
            }
            , tempResults);
    allResults = tempResults;

Je vais m'arrêter ici-trop de travail pour simplifier jusqu'à un cas de test simple. Mais l'aide est miuch apprécié.

Vous devriez tous faire attention à toute Collection Java qui récupère ses enfants par hashcode, dans le cas où le hashcode de son type enfant dépend de son état mutable. Un exemple:

HashSet<HashSet<?>> or HashSet<AbstaractSet<?>> or HashMap variant:

HashSet récupère un élément par son hashCode, mais son type d'élément est un HashSet, et hashSet.hashCode dépend de l'état de son élément.

Code d'ailleurs:

HashSet<HashSet<String>> coll = new HashSet<HashSet<String>>();
HashSet<String> set1 = new HashSet<String>();
set1.add("1");
coll.add(set1);
print(set1.hashCode()); //---> will output X
set1.add("2");
print(set1.hashCode()); //---> will output Y
coll.remove(set1) // WILL FAIL TO REMOVE (SILENTLY)

La raison est que la méthode remove de HashSet utilise HashMap et identifie les clés par hashCode, tandis que le hashCode de AbstractSet est dynamique et dépend des propriétés mutables de lui-même.

Avez-vous essayé quelque chose comme

boolean removed = allResults.remove(oldData)
if (!removed) // COMPLAIN BITTERLY!

En d'autres termes, supprimez l'objet de L'ensemble et cassez la boucle. Cela ne fera pas que le Iterator se plaint. Je ne pense pas que ce soit une solution à long terme mais vous donnerait probablement quelques informations sur le hashCode, equals et equalsData méthodes

C'est presque certainement le cas où les hashcodes ne correspondent pas aux anciennes et nouvelles données qui sont "equals()". J'ai déjà rencontré ce genre de chose et vous finissez essentiellement par cracher des hashcodes pour chaque objet et la représentation de la chaîne et essayer de comprendre pourquoi l'inadéquation se produit.

Si vous comparez des éléments de base de données pré/post, il perd parfois les nanosecondes (en fonction de votre type de colonne DB) qui peuvent