# HashMap Parameter übergeben



## Ich4 (8. Jun 2011)

Hallo,

ich bin gerade an einer Aufgabe dran, für die ich leider keine Lösungen habe ...

Es geht darum, dass ich eine HashMap habe... eine vorgegebene Main Klasse und die Ausgabe folgende sein sollte:

[]
1
[HELLO]
2
[HELLO]


Bei mir wird allerdings das HELLO nicht angezeigt. Der Zähler funktioniert.


```
public boolean add(String newString){
	keyundzaehler.put(newString, i++);
	return true;
	}
```

Fehler müsste doch dann also hier liegen, oder?

Hier noch der ganze Code von meiner Klasse... falls nötig.


```
import java.util.HashMap;
import java.util.HashSet;


public class CountedSet extends HashSet<String>{
	
	HashMap<String, Integer> keyundzaehler = new HashMap<String, Integer>();
	static int i = 0;
	Object o;
	
	public boolean add(String newString){
	keyundzaehler.put(newString, i++);
	return true;
	}
	
	public void clear() throws UnsupportedOperationException{
		keyundzaehler = null;
	}
	
	public boolean remove(Object o){
		this.o = o;
		return true;
	}
	
	public int getCount(String string){
		return i;
	}
	

}
```

Ich hoffe das war einigermaßen verständlich ausgedrückt. Ich bin einfach ne totale Pfeife in Java 
Vielen Dank fürs lesen. Schöne Grüße


----------



## faetzminator (8. Jun 2011)

Irgendwie macht das alles überhaupt keinen Sinn... Was ist dein Ziel? Ein Set, welches nebst dem String noch eine eindeutige ID (fortlaufend) hinzufügt?


----------



## Ich4 (8. Jun 2011)

Hallo,

ja ich soll eine HashMap erstellen wo ich quasi immer "HALLO" hinzufüge und jedes mal wenn ich Hallo hinzufüge ... is der key eben +1 also fortlaufend nummeriert.

Hier wäre die Aufgabenstellung dazu, falls ich mich zu unklar ausdrücke:



> Die Menge selbst wird von der Klasse HashSet verwaltet. (Hinweis: Denken Sie dabei
> an das Beispiel SetList aus der Vorlesung.)
> 
> Weiter enthält die Klasse folgende Methoden:
> ...


----------



## Guardi (8. Jun 2011)

Kann es sein dass du <Key, Value> bei HashMap vertauscht hast?
Kann mir kaum vorstellen dass du den String als Key haben möchtest, doch eher das Integer?


----------



## Ich4 (8. Jun 2011)

Hallo,

das spielt ne Rolle? Auch wenn ich das oben so festlege?  Ok ja, dann hab ich das vertauscht.

Aber hätte es etz geändert und es geht nach wie vor nicht... :/


----------



## muemmel_0811 (8. Jun 2011)

Zeig doch auch mal den Code, wo Du diese Methoden aufrufst und Dir die Inhalte der HashMaps ausgeben lässt.


----------



## Ich4 (8. Jun 2011)

Der Code is so gegeben und sollte nicht geändert werden... (sofern kein Fehler drin is )


```
public class CountedMain
{
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args)
    {
        // TODO code application logic here
        CountedSet cs = new CountedSet();
        System.out.println(cs);
        cs.add("HELLO");
        System.out.println(cs.getCount("HELLO"));
        System.out.println(cs);
        cs.add("HELLO");
        System.out.println(cs.getCount("HELLO"));
        System.out.println(cs);

    }

}
```


Vielen Dank schonmal für eure schnellen Antworten


----------



## faetzminator (8. Jun 2011)

Irgendwie glaube ich, dass du nicht einen Count für alle Wörter benötigst, sondern pro Wort einen. Also einfach schauen, ob das Element bereits in der Map ist. Wenn ja, einfach die Value um eins erhöhen. Wenn nein, Value und 1 adden.

Edit: Warum erbst du eigentlich von HashSet<String> und nicht vom Interface Set<T>? ich würde [c]public class CountedSet<T> implements Set<T>[/c]. Dann einfach (wie du es bereits machst) intern eine HashMap verwenden und alle Methoden ausser [c]add(T o)[/c] und [c]addAll(Collection<? extends T> c)[/c] einfach auf der Map (bzw. wenn nicht verfügbar von Map#keySet()) aufrufen.


----------



## Ich4 (8. Jun 2011)

faetzminator hat gesagt.:


> Irgendwie glaube ich, dass du nicht einen Count für alle Wörter benötigst, sondern pro Wort einen. Also einfach schauen, ob das Element bereits in der Map ist. Wenn ja, einfach die Value um eins erhöhen. Wenn nein, Value und 1 adden.
> 
> Edit: Warum erbst du eigentlich von HashSet<String> und nicht vom Interface Set<T>? ich würde [c]public class CountedSet<T> implements Set<T>[/c]. Dann einfach (wie du es bereits machst) intern eine HashMap verwenden und alle Methoden ausser [c]add(T o)[/c] und [c]addAll(Collection<? extends T> c)[/c] einfach auf der Map (bzw. wenn nicht verfügbar von Map#keySet()) aufrufen.



Ich muss von HashSet<String> erben, das ist auch so vorgegeben. Sry das habe ich vergessen mit zu kopieren.

Hm ersteres klingt logisch. Würd wohl auch mehr Sinn ergeben.

Trotzdem würd mich interessieren warum bei mir das HALLO nicht erscheint...
Ich find da ums verrecken meinen Fehler nicht 

Danke!


----------



## Ich4 (8. Jun 2011)

Folgendes gehört noch zur Aufgabenstellung:



> Schreiben Sie eine Klasse CountedSet, die von HashSet<String> erbt.
> 
> 
> Die Klasse benötigt eine Map, die zu jedem String-Element aus der Menge (key) einen
> ...



Hab mich wohl bei copy paste zu blöd angestelt  sry!


----------



## Crian (8. Jun 2011)

Ich finde die Aufgabe schon seltsam. Hier mal meine freie Interpretation:


```
package javathings.countedset;

import java.util.HashMap;
import java.util.Map;

/**
 * Diese Klasse stellt eine Menge dar, die zählt, wieviele Elemente sie jeweils
 * von einem Element beinhaltet.
 */

public class CountedSet<T> {

    /** Datenvorhaltung */
    private Map<T, Integer> data;

    /** Konstruktor */
    public CountedSet() {
        data = new HashMap<T, Integer>();
    }

    /**
     * Fügt das Element hinzu, falls es noch nicht in der Menge existiert, oder
     * zählt den Zähler hoch.
     *
     * @param element
     *            Hinzuzufügendes Element.
     */
    public void add(T element) {
        if (data.containsKey(element)) {
            int count = data.get(element);
            data.put(element, count + 1);
        }
        else {
            data.put(element, 1);
        }
    }

    /** Entfernt alle Elemente. */
    public void clear() {
        data.clear();
    }

    /**
     * Entfernt das Element, falls vorhanden ist (unabhängig davon, wie hoch
     * sein Zähler ist).
     *
     * @param element
     *            Zu entfernendes Element.
     * @return true, wenn das Element vorhanden war.
     */
    public boolean remove(T element) {
        if (data.containsKey(element)) {
            data.remove(element);
            return true;
        }
        else
            return false;
    }

    /**
     * Entfernt das Element, falls es einmal vorhanden ist. Ist es öfter
     * vorhanden, so wird der Zähler reduziert.
     *
     * @param element
     *            Zu verringerndes Element.
     * @return true, wenn das Element vorhanden war.
     */
    public boolean removeOne(T element) {
        if (data.containsKey(element)) {
            int count = data.get(element);
            if (count > 1)
                data.put(element, count - 1);
            else
                data.remove(element);
            return true;
        }
        else
            return false;
    }

    /**
     * Gibt zurück, wie oft das Element vorhanden ist.
     *
     * @param element
     *            Zu überprüfendes Element.
     */
    public int getCount(T element) {
        if (data.containsKey(element))
            return data.get(element);
        else
            return 0;
    }

}
```

Und die dazugehörigen Tests:


```
package javathings.countedset;

import static org.junit.Assert.*;
import javathings.countedset.CountedSet;

import org.junit.Test;

public class CountedSetTest {

    @Test
    public void create() {
        CountedSet<String> set = new CountedSet<String>();
        assertNotNull(set);
    }

    @Test
    public void fillAndGetCount() {
        CountedSet<String> set = new CountedSet<String>();
        set.add("Hallo");
        int expected = 1;
        int actual = set.getCount("Hallo");
        assertEquals(expected, actual);
    }

    @Test
    public void getNotExistent() {
        CountedSet<String> set = new CountedSet<String>();
        int expected = 0;
        int actual = set.getCount("Hallo");
        assertEquals(expected, actual);
    }

    @Test
    public void fillTwoAndGetCount() {
        CountedSet<String> set = new CountedSet<String>();
        set.add("Hallo");
        set.add("Hallo");
        int expected = 2;
        int actual = set.getCount("Hallo");
        assertEquals(expected, actual);
    }

    @Test
    public void fillTwoAndRemoveOneAndGetCount() {
        CountedSet<String> set = new CountedSet<String>();
        set.add("Hallo");
        set.add("Hallo");
        set.removeOne("Hallo");
        int expected = 1;
        int actual = set.getCount("Hallo");
        assertEquals(expected, actual);
    }

    @Test
    public void fillTwoDifferentAndGetCount() {
        CountedSet<String> set = new CountedSet<String>();
        set.add("Hallo");
        set.add("Hallo Welt");
        int expected = 1;
        int actual = set.getCount("Hallo");
        assertEquals(expected, actual);
    }

    @Test
    public void fillTwoAndRemoveAllAndGetCount() {
        CountedSet<String> set = new CountedSet<String>();
        set.add("Hallo");
        set.add("Hallo");
        set.remove("Hallo");
        int expected = 0;
        int actual = set.getCount("Hallo");
        assertEquals(expected, actual);
    }

    @Test
    public void testOtherThanString() {
        CountedSet<Character> set = new CountedSet<Character>();
        set.add('a');
        set.add('b');
        set.add('c');
        set.add('b');
        set.add('c');
        set.add('c');
        set.add('d');
        int expected = 1;
        int actual = set.getCount('a');
        assertEquals(expected, actual);
        expected = 2;
        actual = set.getCount('b');
        assertEquals(expected, actual);
        expected = 3;
        actual = set.getCount('c');
        assertEquals(expected, actual);
        expected = 1;
        actual = set.getCount('d');
        assertEquals(expected, actual);
    }

}
```


----------



## faetzminator (8. Jun 2011)

Das macht sowas von keinen Sinn. Wenn deine Menge von HashSet (bzw. von deiner Klasse) verwaltet werden soll, du aber noch eine Map hast, welche die Keys sowieso auch beinhaltet (bzw. ebenfalls noch ein Set)... Und dann erst noch ohne Generics :autsch:
Dann musst du halt alle Methoden zuerst mit [c]super....()[/c] delegieren und danach das gleiche noch auf der Map machen...

Btw - als Antwort auf Crian's Code - , so würde ich es machen, wenn man von Set<T> ableiten soll:

```
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Foo<T> implements Set<T> {

    public static void main(String[] args) {
        // TODO code application logic here
        Foo<String> cs = new Foo<String>();
        cs.add("HELLO");
        System.out.println(cs.getCount("HELLO"));
        cs.add("HELLO");
        System.out.println(cs.getCount("HELLO"));

    }

    Map<T, Integer> map = new HashMap<T, Integer>();

    public boolean add(T o) {
        map.put(o, getCount(o) + 1);
        return true;
    }

    public int getCount(T o) {
        if (map.containsKey(o)) {
            return map.get(o);
        }
        return 0;
    }

    public boolean addAll(Collection<? extends T> c) {
        for (T item : c) {
            add(item);
        }
        return true;
    }

    public void clear() {
        map.clear();
    }

    public boolean contains(Object o) {
        return map.containsKey(o);
    }

    public boolean containsAll(Collection<?> c) {
        return map.keySet().containsAll(c);
    }

    public boolean isEmpty() {
        return map.isEmpty();
    }

    public Iterator<T> iterator() {
        return map.keySet().iterator();
    }

    public boolean remove(Object o) {
        map.remove(o);
        return true;
    }

    public boolean removeAll(Collection<?> c) {
        return map.keySet().removeAll(c);
    }

    public boolean retainAll(Collection<?> c) {
        return map.keySet().retainAll(c);
    }

    public int size() {
        return map.size();
    }

    public Object[] toArray() {
        return map.keySet().toArray();
    }

    public <T> T[] toArray(T[] a) {
        return map.keySet().toArray(a);
    }
}
```


----------



## Ich4 (8. Jun 2011)

faetzminator hat gesagt.:


> Das macht sowas von keinen Sinn.



Machen kaum welche der Aufgaben die wir zu lösen hatten ;D



faetzminator hat gesagt.:


> Dann musst du halt alle Methoden zuerst mit [c]super....()[/c] delegieren und danach das gleiche noch auf der Map machen...



Wieso muss ich zuerst mit super?
Heißt mein Code kann man in die Tonne kicken, nehm ich an? :/
Tut mir echt leid dass ich mir gar so blöd anstelle.

Crian, danke für deinen Code  Ich werd mir den mal zu Seite legen und genauer anschauen. Ich brauch da ne gute Weile für...


----------



## faetzminator (8. Jun 2011)

Warum? Weil du die Daten immer im Set und in der Map verwalten musst. Mit [c]super[/c] rufst du die Methode auf dem Set auf. Danach musst du das noch auf der Map machen.
Sagen wir, du willst [c]remove()[/c] aufrufen. Entweder musst du dann die Daten in beiden Containern löschen, oder allenfalls auch einfach den Count um eins subtrahieren - solange dieser grösser 1 ist. Aber spätestens dann musst du den Key natürlich auch im Set löschen.


----------



## Crian (8. Jun 2011)

Danke für die Anregung, da hab ich meine Klasse nochmal etwas erweitert und auch Set<T> implementiert.



Ich4 hat gesagt.:


> Crian, danke für deinen Code  Ich werd mir den mal zu Seite legen und genauer anschauen. Ich brauch da ne gute Weile für...



Gern, aber vorsicht, er tut nicht das, was in der Aufgabe steht, nur das, was ich zu der Aufgab passend als sinnvoll erachtet habe


----------

