À l'aide de Java, comment puis-je comparer chaque entrée dans la table de hachage pour chaque autre entrée dans la même table de hachage sans dupliquer les comparaisons?

Je suis actuellement à l'aide de 2 boucles for pour comparer toutes les entrées, mais je suis en double comparaisons. Parce que HashMaps ne sont pas commandé, je ne peux pas comprendre comment éliminer les comparaisons qui ont déjà été faites. Par exemple, j'ai quelque chose comme:

    for(Entry<String, String> e1: map.entrySet())
    { 
        for(Entry<String, String> e2: map.entrySet())
        {    
          if (e1.getKey() != e2.getKey())
            {
           //compare e1.getValue() to e2.getValue() 
            }
        }
     }

Le problème, c'est que la première entrée sera comparée à la deuxième, puis la troisième et ainsi de suite. Mais alors que le second sera de nouveau par rapport à la première entrée et ainsi de suite. Et puis la troisième entrée est comparée à la première, puis la seconde, puis la 4ème entrée, etc. Est-il une meilleure façon de parcourir HashMaps pour éviter de faire un double des comparaisons?

Informations supplémentaires:

Pour être plus précis et nous espérons répondre à vos questions, la table de hachage que j'ai est de stocker les noms de fichiers (les touches) et le contenu du fichier (les valeurs) - seulement les fichiers texte. La table de hachage a été rempli en traversant un répertoire qui contient les fichiers que je veux comparer. Alors ce que je fais est en cours d'exécution des paires de fichiers par le biais de certains algorithmes pour déterminer la similarité entre chaque paire de fichiers. Je n'ai pas besoin de comparer le fichier 1 fichier 2, puis le fichier 2 fichier 1 encore une fois, comme je l'ai seulement besoin de 2 fichiers à comparer la fois. Mais je n'ai besoin de tous les fichiers à comparer à tous les autres fichier une fois. Je suis tout nouveau à travailler avec HashMaps. agim la réponse ci-dessous peut travailler pour mes fins. Mais je vais aussi essayer d'envelopper mon cerveau autour de Evgeniy Dorofeev et Peter Lawrey les solutions ci-dessous. J'espère que cela vous aide à comprendre les choses mieux.

Êtes-vous essayer de trouver si une valeur est répétée dans la carte? Si oui, avez-vous besoin de savoir ce que les touches de la carte à un double de la valeur?
Merci beaucoup tout le monde. J'ai ajouté un edit pour aider à expliquer plus et nous espérons répondre à vos questions.

OriginalL'auteur Lani1234 | 2013-01-07

4

Si vous n'êtes pas prudent, le coût de l'élimination des doublons pourraient plus élevé que le coût de la redondance des comparaisons sur les clés au moins.

Vous pouvez commander les clés à l'aide de System.identityHashCode(x)
```
for(Map.Entry<Key, Value> entry1: map.entrySet()) {
   Key key1 = entry1.getKey();
   int hash1 = System.identityHashCode(key1);
   Value value1 = entry1.getValue();
   for(Map.Entry<Key, Value> entry2: map.entrySet()) {
       Key key2 = entry2.getKey();
       if (key1 > System.identityHashCode(key2)) continue;

       Value value2 = entry1.getValue();
       //compare value1 and value2;
   }
}
```
Je pense qu'il y a une faute de frappe à la ligne 7. Ne devrait-elle pas être if (hash1 > System.identityHashcode(key2)) ????
Je vous remercie. Il devrait être identityHashCode
Et ligne 6 devrait être la Clé de cle2 = entry2.getKey();, à droite? J'aime cette solution de plus en plus et plus de fois je l'ai lu à travers.
Je vous remercie. Il existe un très faible risque que les deux objets ont la même clé, mais je suppose que cela n'a pas trop d'importance.
devraient valeur de valeur2 = entry1.getValue(); valeur2 = entry2.getValue(); ?

OriginalL'auteur Peter Lawrey
3

Comment au sujet de cette solution:
```
String[] values = map.values().toArray(new String[map.size()]);
for (int i = 0; i < values.length; i++) {
  for (int j = i+1; j<values.length; j++) {
    if (values[i].equals(values[j])) {
      //...
    }
  }
}
```
Cette solution pourrait fonctionner pour moi. Si je ont été, également, de créer un tableau pour contenir les touches, les touches sont stockées dans son tableau dans le même ordre que les valeurs sont stockées dans son ensemble?
+1. Classique et simple. Vous pouvez également utiliser une ArrayList (au lieu de la Chaîne[]). c'est à dire ArrayList values = new ArrayList(map.values); puis utilisez la taille et obtenir à la place de la longueur et de la [].

OriginalL'auteur agim

Essayer

    HashMap<Object, Object> map = new HashMap<>();
    Iterator<Entry<Object, Object>> i = map.entrySet().iterator();
    while (i.hasNext()) {
        Entry next = i.next();
        i.remove();
        for (Entry e : map.entrySet()) {
            e.equals(next);
        }
    }

Noter qu'il n'y a pas de sens de comparer des clés dans une table de hachage ils ne sont pas toujours égaux. Qu'est qu'on pourrait effectuer une itération /comparer uniquement les valeurs de

OriginalL'auteur Evgeniy Dorofeev

Si je comprends bien, vous voulez juste savoir si il y a des doublons dans la carte des valeurs? Si oui:

Set<String> values = new HashSet<String>(map.values());
boolean hasDuplicates = values.size() != map.size();

Ce qui pourrait être plus efficace si vous coup de pied une fois que vous trouvez le premier double:

Set<String> values = new HashSet<String>();
for (String value : map.values()) {
  if (!values.add(value)) {
    return true;
  }
}
return false;

OriginalL'auteur JimN

public static boolean compareStringHashMaps(Map<String, String> expectedMap, Map<String, String> actualMap) throws Exception
{
    logger.info("## CommonFunctions | compareStringHashMaps() ## ");
        Iterator iteratorExpectedMap = expectedMap.entrySet().iterator();
        Iterator iteratorActualMap = actualMap.entrySet().iterator();
        boolean flag = true;
        while (iteratorExpectedMap.hasNext() && iteratorActualMap.hasNext()){
            Map.Entry expectedMapEntry = (Map.Entry) iteratorExpectedMap.next();
            Map.Entry actualMapEntry = (Map.Entry) iteratorActualMap.next();
            if(!expectedMapEntry.getKey().toString().trim().equals(actualMapEntry.getKey().toString().trim()))
            {   
                flag = false;
                break;
            }
            else if (!expectedMapEntry.getValue().toString().trim().equals(actualMapEntry.getValue().toString().trim()))
            {
                flag = false;
                break;
            }
        }   
        return flag;

}

En quoi diffèrent les 5 autres, 4 ans, des solutions?

OriginalL'auteur Dinuk Caldera

-1

Vous pouvez essayer d'utiliser un tableau 2D de résultats. Si le résultat est déjà rempli, alors ne pas effectuer la comparaison de nouveau. Cela a aussi l'avantage de stocker les résultats pour les utiliser plus tard.

Donc, pour un int result, vous seriez à la recherche à quelque chose comme ceci: Integer[][] results = new Integer[map.entrySet().size()][map.entrySet().size()];Ce initialise le tableau pour les valeurs null et vous permet de vérifier les résultats existants avant la comparaison. Une chose importante à noter ici est que chaque résultat de comparaison doivent être stockés dans le tableau à deux reprises, à l'exception des comparaisons à lui-même. par exemple, la comparaison entre l'index 1 index et 2 doivent être stockés dans results[1][2] et result[2][1].

Espère que cette aide.

OriginalL'auteur Maybe_Factor

Vous devez vous connecter pour publier un commentaire.