vereinfachtes Wörterbuch in java modellieren

[zDieTaschenlampe]

Hallo,
da ich in Sachen modellieren noch nicht so stark bin und Übung bekanntlich den Meister macht, hab ich mir lauter Modellierungsaufgaben aus dem Netz gesucht und bin auf eine gestoßen, die scheinbar einfach aussah, aber mich jetzt doch vor paar Problemen setzt. Es geht also um ein Wörterbuch. Es soll dabei aber eine Textdatei eingelesen ( bisschen verwirrend, hab ich noch nichts zu, aber sollte gehen) werden , in der eben die Wörterpaare von Startsprache und Zielsprache in einer geeigneten Datenstruktur alphabetisch geordnet (Startsprache soll alphabetisch geordnet sein). Dazu habe ich einfach TreeSet benutzt, das alles alphabetisch korrekt anordnet. Hab jetzt auch die Methoden print, print(letter), translate (word ), translate (sentence) zu implementieren und das hab ich auch mehr oder weniger erfolgreich. Hab eigentlich, falls ich den Textdateileser selber hinbekommen, nur 2 Probleme/ Fragen:

1. Modellierung : Ich hab jetzt nur eine Dictionary Class und nehme die Textdatei Wörter als String, weil damit einfacher zu arbeiten ist und die Methoden einfach zu implementieren sind. Aber würdet ihr bzw sollte man eine Klasse für die Wörter haben ? Wenn ja, gäbe es dann auch eine Möglichkeit auf die ganzen String Methoden zuzugreifen wie z. Bsp .toLowerCase .charAt(i) etc weil die bräuchte ich. Hatte nämlich zuerst eine Klasse dafür, aber wusste nicht, wie das geht

2. Findet ihr meine gewählte Datenstruktur die sinnvollste und geeignetste dafür oder gäbe es was besseres ? Hab nämlich das Problem, dass ich nicht weiß, wie ich bei einem gleichen key ( also dem gleichen Wort aus der Startsprache) mehrere Values ( Übersetzungen) zuordnen kann. Also als Bsp Startsprache wäre "klein" und ich füg dem Wörterbuch jetzt in 3 Schritten für klein tiny, small. little hinzu. Dann möchte ich bei print später, wenn das klein geprintet wird auch alle 3 Übersetzungen in einer Zeile daneben haben. Ist das irgendwie realisierbar ? Oder hat wer eine Lösung dafür.

Falls ihr meine Code dazu sehen wollt, kann ich auf Anfrage gerne auch reinschicken, aber vielleicht klappt es ja auch so ? Wäre um jegliche Hilfe dankbar

 

[mihe7]

Wege gibt es viele. Wozu brauchst Du denn toLowerCase etc.? Gibt es einen Grund dafür, dann kann es z. B. sinnvoll sein, eine Wort-Klasse zu basteln. Ansonsten halte ich das persönlich für Overkill - aber das ist auch eine "Glaubensfrage".

Ein Starter:

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Dictionary {
    private static final List<String> NONE = new ArrayList<>();
    private Map<String, List<String>> words = new HashMap<>();

    public void add(String word, String translation) {
        List<String> translations = words.computeIfAbsent(word, w -> new ArrayList<>());
        translations.add(translation);
    }

    public List<String> getTranslations(String word) {
        return Collections.unmodifiableList(words.getOrDefault(word, NONE));
    }
}

 

[zDieTaschenlampe]

Wege gibt es viele. Wozu brauchst Du denn toLowerCase etc.? Gibt es einen Grund dafür, dann kann es z. B. sinnvoll sein, eine Wort-Klasse zu basteln. Ansonsten halte ich das persönlich für Overkill - aber das ist auch eine "Glaubensfrage".

Ein Starter:

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Dictionary {
    private static final List<String> NONE = new ArrayList<>();
    private Map<String, List<String>> words = new HashMap<>();

    public void add(String word, String translation) {
        List<String> translations = words.computeIfAbsent(word, w -> new ArrayList<>());
        translations.add(translation);
    }

    public List<String> getTranslations(String word) {
        return Collections.unmodifiableList(words.getOrDefault(word, NONE));
    }
}

Ich hab es so bisher :

import java.util.Map;
import java.util.TreeMap;

import edu.kit.informatik.Terminal;

public class Dictionary {

    Map<String, String> dictionary = new TreeMap<String, String>();

    private static boolean isEnabled = true;

    public void add(String germanWord, String translatedWord) {
        dictionary.put(germanWord, translatedWord);
    }

    public boolean remove(String word) {
        for (String i : dictionary.keySet()) {
            if (i.equals(word)) {
                dictionary.remove(word);
                return true;
            }
        }
        return false;

    }

    
    eachten !public void print() {
        if (dictionary.size() == 0) {
            Terminal.printError("");
        }
        for (String i : dictionary.keySet()) {
            Terminal.printLine(i + " - " + dictionary.get(i));
        }
    }

    public void print(char letter) {

        if (dictionary.size() == 0) {
            Terminal.printError("");
        }

        for (String i : dictionary.keySet()) {
// bei print d wird Groß und Kleinschreibung ignoriert laut Aufgabe z Bsp und deswegen muss ich alle wörter mit großem und kleinem d überprüfen
            if (i.toLowerCase().charAt(0) != letter || i.toUpperCase().charAt(0) != letter) {
                Terminal.printError("");
                break;
            } else if (i.toLowerCase().charAt(0) == letter || i.toUpperCase().charAt(0) == letter) {
                Terminal.printLine(i + " - " + dictionary.get(i));
            }
        }
    }

    
    public void translate(String word) {
        for (String i : dictionary.keySet()) {
            if (i.equals(word)) {
                Terminal.printLine(dictionary.get(i));
            }
        }
    }

    public void translateSentence(String sentence) {
        String[] sentenceSplitted = sentence.split(" ");
        String newSent = "";
        for (int j = 0; j < sentenceSplitted.length; j++) {
            for (String i : dictionary.keySet()) {
                if (sentenceSplitted[j].equals(i)) {
                    newSent += dictionary.get(i) + " ";
                }
            }
        }
        Terminal.printLine(newSent);
    }

    public void quit() {
        isEnabled = !isEnabled;
    }

Kann ich deine Methode für die Duplikaten values auch auf meinen Code anwenden ? Mir fällt nämlich nur, dass bei der translate Methode alle entsprechenden Überstzungen mitausgegeben werden und bei der translate (sentence) das gleiche nur mit Sätzen

 

[mihe7]

Klar, die TreeMap ist ja nur eine andere Implementierung der Map. Es wird dann ein Wort nicht auf ein übersetztes Wort sondern auf eine Liste von übersetzten Wörtern abgebildet.

 

[zDieTaschenlampe]

Wege gibt es viele. Wozu brauchst Du denn toLowerCase etc.? Gibt es einen Grund dafür, dann kann es z. B. sinnvoll sein, eine Wort-Klasse zu basteln. Ansonsten halte ich das persönlich für Overkill - aber das ist auch eine "Glaubensfrage".

Ein Starter:

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Dictionary {
    private static final List<String> NONE = new ArrayList<>();
    private Map<String, List<String>> words = new HashMap<>();

    public void add(String word, String translation) {
        List<String> translations = words.computeIfAbsent(word, w -> new ArrayList<>());
        translations.add(translation);
    }

    public List<String> getTranslations(String word) {
        return Collections.unmodifiableList(words.getOrDefault(word, NONE));
    }
}

Gibt es keine simplere Möglichkeit ? Weil ich versteh noch nicht mal alles. Angefangen wieso du eine statitsche finale Liste erzeugst
Dann die Methoden .computeIfAbsent ?
Dann was macht w -> new ArrayList
etc

Gibt es nicht eine andere Möglichkeit. die auch in mein Schema vom Still passt. Kann auch simple und schlechte Laufzeit haben, aber ich möchte es auch verstehen

 

[mihe7]

Der Pfeil (->) ist die Java-Notation für Lambda-Ausdrücke (=anonyme Funktionen). Man kann das auch ohne Lambdas und ohne computeIfAbsent schreiben:

    public void add(String word, String translation) {
        List<String> translations = words.get(word);
        if (translations == null) {
            translations = new ArrayList<>();
            words.put(translations);
        }
        translations.add(translation);
    }

Angefangen wieso du eine statitsche finale Liste erzeugst

static final verwendet man in Java für Konstanten. NONE ist somit einfach eine Konstante, die mit einer leeren Liste belegt wird. Damit muss nur einmalig die Liste erzeugt werden. Würde man dagegen

    public List<String> getTranslations(String word) {
        return Collections.unmodifiableList(words.getOrDefault(word, new ArrayList<>()));
    }

schreiben, würde jedesmal, wenn ein Wort nicht gefunden wurde, eine neue, leere Liste erzeugt. Collections.unmodifiableList sorgt dafür, dass die zurückgegebene Liste nicht verändert werden kann.

Wenn Dir alles egal ist, kannst Du die zweite Methode auch einfach so schreiben:

    public List<String> getTranslations(String word) {
        List<String> translations = words.get(word);
        if (translations == null) {
            translations = new ArrayList<>();
        }
        return translations;
    }

 

[zDieTaschenlampe]

Der Pfeil (->) ist die Java-Notation für Lambda-Ausdrücke (=anonyme Funktionen). Man kann das auch ohne Lambdas und ohne computeIfAbsent schreiben:

    public void add(String word, String translation) {
        List<String> translations = words.get(word);
        if (translations == null) {
            translations = new ArrayList<>();
            words.put(translations);
        }
        translations.add(translation);
    }

static final verwendet man in Java für Konstanten. NONE ist somit einfach eine Konstante, die mit einer leeren Liste belegt wird. Damit muss nur einmalig die Liste erzeugt werden. Würde man dagegen

    public List<String> getTranslations(String word) {
        return Collections.unmodifiableList(words.getOrDefault(word, new ArrayList<>()));
    }

schreiben, würde jedesmal, wenn ein Wort nicht gefunden wurde, eine neue, leere Liste erzeugt. Collections.unmodifiableList sorgt dafür, dass die zurückgegebene Liste nicht verändert werden kann.

Wenn Dir alles egal ist, kannst Du die zweite Methode auch einfach so schreiben:

    public List<String> getTranslations(String word) {
        List<String> translations = words.get(word);
        if (translations == null) {
            translations = new ArrayList<>();
        }
        return translations;
    }

Danke für deine Erklärung, aber inwiefern kombinierst du nun die ursprüngliche map mit der Liste ? Ich versuche das gerade für mich umzubauen ( du siehst ja oben meinen Stand ohne Liste und die Methoden die ich brauche). Kann ich kleine Änderungen machen oder muss ich alles ändern ? Vielleicht könntest du mir ja beim Umbauen der Methoden helfen

Edit : Hab jetzt erst gesehen, dass du mir sogar ein Beispiel gezeigt hast und war von deiner Namensgebung confused, aber ich danke dir. Ich versuche mein bestes Alleine, aber vielleicht komm ich morgen oder irgendwann doch auf dich zurück!

 

[zDieTaschenlampe]

Der Pfeil (->) ist die Java-Notation für Lambda-Ausdrücke (=anonyme Funktionen). Man kann das auch ohne Lambdas und ohne computeIfAbsent schreiben:

    public void add(String word, String translation) {
        List<String> translations = words.get(word);
        if (translations == null) {
            translations = new ArrayList<>();
            words.put(translations);
        }
        translations.add(translation);
    }

static final verwendet man in Java für Konstanten. NONE ist somit einfach eine Konstante, die mit einer leeren Liste belegt wird. Damit muss nur einmalig die Liste erzeugt werden. Würde man dagegen

    public List<String> getTranslations(String word) {
        return Collections.unmodifiableList(words.getOrDefault(word, new ArrayList<>()));
    }

schreiben, würde jedesmal, wenn ein Wort nicht gefunden wurde, eine neue, leere Liste erzeugt. Collections.unmodifiableList sorgt dafür, dass die zurückgegebene Liste nicht verändert werden kann.

Wenn Dir alles egal ist, kannst Du die zweite Methode auch einfach so schreiben:

    public List<String> getTranslations(String word) {
        List<String> translations = words.get(word);
        if (translations == null) {
            translations = new ArrayList<>();
        }
        return translations;
    }

Ich bräuchte doch nochmal deine Hilfe bezüglich paar Dingen :

Bezüglich der print Methode, hab ich das jetzt so umgesetzt :

public void print() {
        if (dictionary.size() == 0) {
            Terminal.printError("");
        }
        for (String i : dictionary.keySet()) {
            Terminal.printLine(i + " - " + dictionary.get(i).toString().replace("[", "").replace("]", "")); // Da ich ja eine Liste von Wörtern printe, kommen die als [word, word1]
            // deswegen diese replace Methode. Gibt es dafür eine schönere Methode ?
        }
    }
    
    2. problem ist dass bei mehreren Übersetzungen die Ausgabe so brauche Meer - ocean,sea aber ich kriege Meer - ocean, sea

Bei der translate ( word) Methode das gleiche wie bei print. Also statt ocean, sea brauche ich ocean,sea (Ohne dieses Leerzeichen) und meine größte Schwierigkeit ist die translate Sentence Methode, denn hier muss jede Möglichkeit zeilenweise übersetzt werden, aber kannst du mir vielleicht zeigen wie ? Mein Code gerade :

public void translateSentence(String sentence) {
        String[] sentenceSplitted = sentence.split(" ");
        String newSent = "";
        for (int j = 0; j < sentenceSplitted.length; j++) {
            for (String i : dictionary.keySet()) {
                if (sentenceSplitted[j].equals(i)) {
                    newSent += dictionary.get(i) + " ";
                }
            }
        }
        Terminal.printLine(newSent);
    }
    
    liefer bei translate("Das Meer") : The - ocean, sea aber brauche
    The sea
    The ocean
    
    Ist das realisierbar ?

 

[mihe7]

Wo kommt der Artikel her?

 

[zDieTaschenlampe]

Wo kommt der Artikel her?

Ich hab zuvor paar Wörter hinzugefügt zum Beispiel der die das (entsprechend mit Übersetzung) und da kommt der artikel her

 

[mihe7]

Naja, Du musst halt jede Übersetzung ausgeben. Eine einfache Schleife und gut ists.