Comment comparer deux cartes par leurs valeurs

Vos tentatives pour construire des chaînes différentes en utilisant la concaténation va échouer car il est effectué au moment de la compilation. Ces deux cartes ont une seule paire, chaque paire aura "foo" et "barbar" comme la clé/valeur, à la fois à l'aide de la même chaîne de référence.

En supposant que vous voulez vraiment comparer les ensembles de valeurs, sans aucune référence à des touches, c'est juste une affaire de:

Set<String> values1 = new HashSet<>(map1.values());
Set<String> values2 = new HashSet<>(map2.values());
boolean equal = values1.equals(values2);

C'est possible que la comparaison de map1.values() avec map2.values() ne fonctionne - mais il est également possible que l'ordre dans lequel ils sont retournés seront utilisés dans la comparaison d'égalité, ce qui n'est pas ce que vous voulez.

Noter que l'utilisation d'un ensemble a ses propres problèmes - parce que le code ci-dessus serait de considérer qu'une carte de {"a":"0", "b":"0"} et {"c":"0"}, être égal... la valeur ensembles sont égaux, après tout.

Si vous pouvez fournir une définition plus stricte de ce que vous voulez, il sera plus facile pour nous assurer de vous donner la bonne réponse.

OriginalL'auteur Jon Skeet

Pour voir si les deux cartes ont la même valeur, vous pouvez effectuer les opérations suivantes:

• Obtenir leur Collection<V> values() vues
• Envelopper dans List<V>
• Collections.sort ces listes
• Tester si les deux listes sont equals

Quelque chose comme cela fonctionne (même si son type de limites peuvent être améliorées):

static <V extends Comparable<V>>
boolean valuesEquals(Map<?,V> map1, Map<?,V> map2) {
    List<V> values1 = new ArrayList<V>(map1.values());
    List<V> values2 = new ArrayList<V>(map2.values());
    Collections.sort(values1);
    Collections.sort(values2);
    return values1.equals(values2);
}

Harnais de Test:

Map<String, String> map1 = new HashMap<String,String>();
map1.put("A", "B");
map1.put("C", "D");

Map<String, String> map2 = new HashMap<String,String>();
map2.put("A", "D");
map2.put("C", "B");

System.out.println(valuesEquals(map1, map2)); //prints "true"

C'est O(N log N) en raison de Collections.trier.

Voir aussi:

• la Collection<V> value()

---

Pour tester si le clés sont égale est plus facile, parce qu'ils sont Set<K>:

map1.keySet().equals(map2.keySet())

Voir aussi:

• <K> keySet()

OriginalL'auteur polygenelubricants

Cette question est ancienne, mais toujours d'actualité.

Si vous voulez comparer deux cartes par leurs valeurs correspondant à leurs touches, vous pouvez le faire comme suit:

public static <K, V> boolean mapEquals(Map<K, V> leftMap, Map<K, V> rightMap) {
    if (leftMap == rightMap) return true;
    if (leftMap == null || rightMap == null || leftMap.size() != rightMap.size()) return false;
    for (K key : leftMap.keySet()) {
        V value1 = leftMap.get(key);
        V value2 = rightMap.get(key);
        if (value1 == null && value2 == null)
            continue;
        else if (value1 == null || value2 == null)
            return false;
        if (!value1.equals(value2))
            return false;
    }
    return true;
}

OriginalL'auteur Manu M.

Je ne pense pas qu'il y est une "apache-common-comme" outil pour comparer les cartes depuis l'égalité des 2 cartes est très ambigu et dépend du développeur besoins et le plan de mise en œuvre...

Par exemple, si vous comparez les deux hashmaps en java:
- Vous pouvez simplement comparer les clés/valeurs sont les mêmes
- Vous pouvez également comparer si les clés sont ordonnées de la même façon
- Vous pouvez également comparer si la capacité restante est la même
... Vous pouvez comparer un grand nombre de choses!

Ce qu'un tel outil pourrait faire lorsque l'on compare les 2 cartes différentes implémentations telles que:
- Une carte permettre clés null
- L'autre jeter exception d'exécution sur map2.get(null)

Vous feriez mieux de mettre en œuvre votre propre solution en fonction de ce que vous avez vraiment besoin de faire, et je pense que vous avez déjà quelques réponses ci-dessus 🙂

OriginalL'auteur Sebastien Lorber

Le résultat d'égal à égal dans votre exemple est évidemment faux, car vous êtes en comparant la carte un avec certaines valeurs qu'il vide la carte b (probablement un copier-coller de l'erreur). Je recommande d'utiliser des noms de variables (de sorte que vous pouvez éviter ces types d'erreurs) et de faire usage des médicaments génériques, trop.

    Map<String, String> first = new HashMap<String, String>();
    first.put("f"+"oo", "bar"+"bar");
    first.put("fo"+"o", "bar"+"bar");

    Map second = new HashMap();
    second.put("f"+"oo", "bar"+"bar");
    second.put("fo"+"o", "bar"+"bar");

    System.out.println("equals: " + first.equals(second));

La concaténation de vos chaînes n'ont pas d'effet, car il sera fait au moment de la compilation.

OriginalL'auteur Daff

public boolean equalMaps(Map<?, ?> map1, Map<?, ?>map2) {
if (map1==null || map2==null || map1.size() != map2.size()) {
return false;
}
for (Object key: map1.keySet()) {
if (!map1.get(key).equals(map2.get(key))) {
return false;
}
}
return true;
}

OriginalL'auteur stones333