HashMap Parameter übergeben

I

Ich4

Gast
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.

Java:
	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.

Java:
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

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

Ich4

Gast
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:
boolean add (String newString) zählt um 1 hoch, wenn der String in die Menge
eingefügt werden soll.
void clear entfernt alle Elemente im Set, entfernt alle Einträge in der Map.
boolean remove(Object o) entfernt ein gegebenes String-Element aus der Menge sowie
den Eintrag für das gegebene Element in der Map.
int getCount(String string) liefert den Zählerstand zu einem gegebenen String-Element
der Menge.
 

Guardi

Bekanntes Mitglied
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?
 
I

Ich4

Gast
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... :/
 
I

Ich4

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

Java:
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

Gesperrter Benutzer
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.
 
Zuletzt bearbeitet:
I

Ich4

Gast
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!
 
I

Ich4

Gast
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
Zählerstand (value) speichert.


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:

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

Crian

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

Java:
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:

Java:
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

Gesperrter Benutzer
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:
Java:
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);
    }
}
 
Zuletzt bearbeitet:
I

Ich4

Gast
Das macht sowas von keinen Sinn.

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

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

Gesperrter Benutzer
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

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

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 ;)
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
S HashMap mehrere Keys zu einem Value Java Basics - Anfänger-Themen 3
A Daten aus einer HashMap aus einer DB speichern und mit neuen Werten vergleichen Java Basics - Anfänger-Themen 8
T HashMap Lsite gibt die sachen nicht aus wie gewollt. Java Basics - Anfänger-Themen 3
krgewb HashMap Java Basics - Anfänger-Themen 2
B Hashmap richtig bauen, die Tripel auf Zahl abbildet? Java Basics - Anfänger-Themen 10
"java.util.HashMap.get(Object)" is null Java Basics - Anfänger-Themen 10
berserkerdq2 Hashmap, wie prüfe ich ob ein Key schon existiert Java Basics - Anfänger-Themen 19
S Durch HashMap iterieren Java Basics - Anfänger-Themen 8
rafi072001 Sortieren einer HashMap nach Values Java Basics - Anfänger-Themen 2
F gson mit einer Hashmap Java Basics - Anfänger-Themen 2
J JSON-HashMap Java Basics - Anfänger-Themen 3
J Hashmap Java Basics - Anfänger-Themen 13
C Hashmap zickt Java Basics - Anfänger-Themen 9
S HashMap contains() Methode Java Basics - Anfänger-Themen 1
Z Satz aufteilen und die Wörter zählen (HashMap) Java Basics - Anfänger-Themen 15
N enum Attribut von Objekten einer Hashmap ausgeben Java Basics - Anfänger-Themen 6
P Verschachtelte Hashmap Java Basics - Anfänger-Themen 6
I Sortiert eine HashMap nicht gleich wie eine ArrayList? Java Basics - Anfänger-Themen 1
B HashMap alphabetisch sortieren Java Basics - Anfänger-Themen 2
J HashMap Java Basics - Anfänger-Themen 6
M Enum-Variable HashMap zuweisen Java Basics - Anfänger-Themen 5
U Hashmap Iterator selbst implementieren Java Basics - Anfänger-Themen 10
N HashMap in List good practice? Java Basics - Anfänger-Themen 2
K Value eines HashMaps in einer HashMap wiedergeben. Java Basics - Anfänger-Themen 5
O Hashmap, ArrayList, LinkedList Java Basics - Anfänger-Themen 7
O HashMap - ArrayList Java Basics - Anfänger-Themen 29
J Hashmap langsamer als compareTo? Java Basics - Anfänger-Themen 23
E HashMap+Vererbung Java Basics - Anfänger-Themen 11
J Erhöhen eines Values als Integer bei gleichen Keys in HashMap Java Basics - Anfänger-Themen 12
N Methoden HashMap interne Werte miteinander vergleichen Java Basics - Anfänger-Themen 7
W The type Long is not visible HashMap Java Basics - Anfänger-Themen 4
M Objekt mit Hashmap vergleichen Java Basics - Anfänger-Themen 22
S Gibt es für die Klasse HashMap Generic Implementierungen? Java Basics - Anfänger-Themen 11
C HashMap - alle keys haben values der letzten put-Anweisung Java Basics - Anfänger-Themen 3
J Hashmap auslesen Java Basics - Anfänger-Themen 7
F HashMap sortieren <String, Long> Java Basics - Anfänger-Themen 3
GreenTeaYT HashMap dupliziert meine Elemente? Java Basics - Anfänger-Themen 2
shiroX Methoden Morse-Code Übersetzer mit HashMap Java Basics - Anfänger-Themen 5
E HashMap Problem Java Basics - Anfänger-Themen 5
P Hashmap anstatt LinkedList? Java Basics - Anfänger-Themen 6
T HashMap und die Methoden Java Basics - Anfänger-Themen 13
N Methoden Interaktives PDF mit HashMap befüllen Java Basics - Anfänger-Themen 0
Z Hashmap auseinandernehmen und analysieren Java Basics - Anfänger-Themen 7
B Durchlaufen von Hashmap und Arraylist Java Basics - Anfänger-Themen 8
F HashMap oder welches Array? Java Basics - Anfänger-Themen 4
T HashMap Java Basics - Anfänger-Themen 24
L Hashmap mit variablem Key Java Basics - Anfänger-Themen 9
M Collections Probleme mit Hashmap Java Basics - Anfänger-Themen 4
N Collections String in HashMap umwandeln Java Basics - Anfänger-Themen 3
Z HashMap richtig benutzen Java Basics - Anfänger-Themen 2
lgund HashMap // TS3 Query Java Basics - Anfänger-Themen 7
Z Hashmap Iterator löscht nicht Java Basics - Anfänger-Themen 8
E Hashmap Wert auslesen Java Basics - Anfänger-Themen 2
S Printstream für einen Hashmap Loop Java Basics - Anfänger-Themen 1
dat_vin OOP Hashmap und Attribute Java Basics - Anfänger-Themen 7
C Check ob eine HashMap schon existiert Java Basics - Anfänger-Themen 16
P Vererbung Eigene HashMap Variante Java Basics - Anfänger-Themen 2
R Hashmap in anderer Klasse nicht benutzbar Java Basics - Anfänger-Themen 1
T Java Hashmap Java Basics - Anfänger-Themen 3
L Gibt es etwas wie "HashMap <String, String, String> Java Basics - Anfänger-Themen 9
K HashMap mit Daten aus ArrayList befüllen Java Basics - Anfänger-Themen 14
S OOP Klasse mit static-Eigenschaften - HashMap füllen Java Basics - Anfänger-Themen 6
O HashMap Fragen Java Basics - Anfänger-Themen 8
T HashMap Werte einfügen, durchsuchen und auslesen Java Basics - Anfänger-Themen 17
M Semantisches Problem HashMap/Netzwerk Java Basics - Anfänger-Themen 4
D HashMap Keys durchlaufen Java Basics - Anfänger-Themen 2
B Zugriff auf csv-Datei per hashmap Java Basics - Anfänger-Themen 5
M HashMap keys ausgeben Java Basics - Anfänger-Themen 2
S In einer Hashmap Klassen regestrieren Java Basics - Anfänger-Themen 2
H Collections Was ist schneller - HashMap + Sort v TreeMap? Java Basics - Anfänger-Themen 75
F HashMap nach kleinstem Value durchsuchen Java Basics - Anfänger-Themen 11
G HashMap Java Basics - Anfänger-Themen 6
F Wortpaare - HashMap - ArrayList Java Basics - Anfänger-Themen 6
M HashMap Frage Java Basics - Anfänger-Themen 3
M HashMap - put() reagiert nicht? Java Basics - Anfänger-Themen 8
N Cast eines Objektes in eine Hashmap Java Basics - Anfänger-Themen 13
A CSV Zeilenweise einlesen und in einer HashMap speichern Java Basics - Anfänger-Themen 12
A Input/Output Hashmap in einem JPanel via JList anzeigen Java Basics - Anfänger-Themen 8
K HashMap auf leere Key-Value-Paare prüfen Java Basics - Anfänger-Themen 14
F Hilfe bei der HashMap. Java Basics - Anfänger-Themen 3
F HashMap vs. TreeMap Java Basics - Anfänger-Themen 5
B HashMap Java Basics - Anfänger-Themen 9
C Collections String[] als value in HashMap Java Basics - Anfänger-Themen 6
V Hashmap Iterieren Java Basics - Anfänger-Themen 4
C Csv File in Hashmap ausgeben Java Basics - Anfänger-Themen 14
T HashMap<String,Object> Werte auslesen Java Basics - Anfänger-Themen 5
I HashMap sortieren Java Basics - Anfänger-Themen 10
I HashMap Java Basics - Anfänger-Themen 11
H Collections Brauche modifizierte HashMap Java Basics - Anfänger-Themen 6
H TreeMap/HashMap synchronisieren Java Basics - Anfänger-Themen 2
A Datentypen Hashmap to Array Java Basics - Anfänger-Themen 11
D HashMap überschreibt Werte Java Basics - Anfänger-Themen 7
pg1337 Interface Comparable-Interface bei HashMap Java Basics - Anfänger-Themen 21
D erweiterte hashmap Java Basics - Anfänger-Themen 5
H HashMap<Int, String> - Er findet die Int-Klasse nicht. Java Basics - Anfänger-Themen 3
L HashMap zu JList Java Basics - Anfänger-Themen 6
S Erste Schritte HashMap Kurze Frage - Werte über Schleife ausgeben Java Basics - Anfänger-Themen 30
F Collections ArrayList oder Hashmap mittel Collections.sychronised Java Basics - Anfänger-Themen 6
B Klassen HashMap Zwei Objekte, gleicher Key Java Basics - Anfänger-Themen 4
N HashMap fehlerhafte Rückgabe Java Basics - Anfänger-Themen 7

Ähnliche Java Themen

Neue Themen


Oben