# Inhalt von HashMap vergleichen



## Jbehrmann (17. Nov 2008)

Hallo erstmal 

Ich habe folgendes Problem:
Ich habe eine Methode geschrieben, die einen String nach Attributen und Werten splittet und diese dann mit hilfe von Hillfsarray in eine HashMap schreibt.


```
String test = "cmd=befehl&attr1=info1&attr2=info2";
...
tmpMap.put("cmd","befehl");
tmpMap.put("attr1","info1");
tmpMap.put("attr2","info2");

return tmpMap;
```

Das funktioniert auch alles ganz wunderbar und ich kann die Daten auch abrufen.
Allerdings hab ich für die Methoden JUnit-Tests angelegt und weiß jetzt nicht, wie ich 
die erwartete Map mit dem gesplitteten String von Hand eingebe.
Bei leerem String erhalte ich auch eine leere Map, aber wie schreibe ich das?


```
HashMap<String, String> expResult = null; //hier weiß ich nicht, wie ich key und value definiere
HashMap<String, String> result = instance.strToMap(string);
...
expected:<null> but was:<{=null}>
```

Hab schon ewig gegooglet und hier gesucht, aber leider ohne Ergebnis.
Ich hoffe ich hab mich nicht all zu wirr ausgedrückt 

Danke schon mal,

MfG,
Jörg


----------



## Eminent (17. Nov 2008)

Also ich muss gestehen ich weiß nicht so ganz wo dein Problem ist aber eine "leere" Map erzeugt man einfach so ...


```
HashMap<String, String> expResult = new HashMap<String, String>();
```


----------



## SlaterB (17. Nov 2008)

die equals-Methode von HashMap bzw. deren super-Klasse AbstractMap ist schon ziemlich fortgeschritten,
reicht die dir nicht?


```
// Comparison and hashing

    /**
     * Compares the specified object with this map for equality.  Returns
     * <tt>true</tt> if the given object is also a map and the two maps
     * represent the same mappings.  More formally, two maps <tt>t1</tt> and
     * <tt>t2</tt> represent the same mappings if
     * <tt>t1.keySet().equals(t2.keySet())</tt> and for every key <tt>k</tt>
     * in <tt>t1.keySet()</tt>, <tt> (t1.get(k)==null ? t2.get(k)==null :
     * t1.get(k).equals(t2.get(k))) </tt>.  This ensures that the
     * <tt>equals</tt> method works properly across different implementations
     * of the map interface.


     *
     * This implementation first checks if the specified object is this map;
     * if so it returns <tt>true</tt>.  Then, it checks if the specified
     * object is a map whose size is identical to the size of this set; if
     * not, it returns <tt>false</tt>.  If so, it iterates over this map's
     * <tt>entrySet</tt> collection, and checks that the specified map
     * contains each mapping that this map contains.  If the specified map
     * fails to contain such a mapping, <tt>false</tt> is returned.  If the
     * iteration completes, <tt>true</tt> is returned.
     *
     * @param o object to be compared for equality with this map.
     * @return <tt>true</tt> if the specified object is equal to this map.
     */
    public boolean equals(Object o) {
	if (o == this)
	    return true;

	if (!(o instanceof Map))
	    return false;
	Map<K,V> t = (Map<K,V>) o;
	if (t.size() != size())
	    return false;

        try {
            Iterator<Entry<K,V>> i = entrySet().iterator();
            while (i.hasNext()) {
                Entry<K,V> e = i.next();
		K key = e.getKey();
                V value = e.getValue();
                if (value == null) {
                    if (!(t.get(key)==null && t.containsKey(key)))
                        return false;
                } else {
                    if (!value.equals(t.get(key)))
                        return false;
                }
            }
        } catch(ClassCastException unused) {
            return false;
        } catch(NullPointerException unused) {
            return false;
        }

	return true;
    }
```
vorher musst du selber auf null prüfen, dass kann ja equals nicht machen, wenn etwa beide null sind

vielleicht schreibst du dir auch eine statische Methode ähnlich meiner:


```
public static boolean equal(Object object1, Object object2)
    {
        if (object1 == null && object2 == null)
        {
            return true;
        }
        if (object1 == null)
        {
            return object2.equals(object1);
        }
        return object1.equals(object2);
    }
```


----------



## Gast (17. Nov 2008)

Nimm einfach nicht die vorgefertigte Testmethode sondern denk dir ne eigene aus.

bsp:   assertTrue(result.containsKey(ANYKEY));
und welche keys enthalten sein müssen ist ja angegeben


----------

