vereinfachtes Wörterbuch in java modellieren

Z

zDieTaschenlampe

Aktives Mitglied
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
 
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:
Java: 
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));
    }
}
 
mihe7 hat gesagt.:
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:
Java: 
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));
    }
}
Zum Vergrößern anklicken....

Ich hab es so bisher :

Code: 
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
 
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.
 
mihe7 hat gesagt.:
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:
Java: 
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));
    }
}
Zum Vergrößern anklicken....

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
 
Der Pfeil (->) ist die Java-Notation für Lambda-Ausdrücke (=anonyme Funktionen). Man kann das auch ohne Lambdas und ohne computeIfAbsent schreiben:
Java: 
    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);
    }

zDieTaschenlampe hat gesagt.:
Angefangen wieso du eine statitsche finale Liste erzeugst
Zum Vergrößern anklicken....
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
Java: 
    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:
Java: 
    public List<String> getTranslations(String word) {
        List<String> translations = words.get(word);
        if (translations == null) {
            translations = new ArrayList<>();
        }
        return translations;
    }
 
mihe7 hat gesagt.:
Der Pfeil (->) ist die Java-Notation für Lambda-Ausdrücke (=anonyme Funktionen). Man kann das auch ohne Lambdas und ohne computeIfAbsent schreiben:
Java: 
    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
Java: 
    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:
Java: 
    public List<String> getTranslations(String word) {
        List<String> translations = words.get(word);
        if (translations == null) {
            translations = new ArrayList<>();
        }
        return translations;
    }
Zum Vergrößern anklicken....

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!
 
mihe7 hat gesagt.:
Der Pfeil (->) ist die Java-Notation für Lambda-Ausdrücke (=anonyme Funktionen). Man kann das auch ohne Lambdas und ohne computeIfAbsent schreiben:
Java: 
    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
Java: 
    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:
Java: 
    public List<String> getTranslations(String word) {
        List<String> translations = words.get(word);
        if (translations == null) {
            translations = new ArrayList<>();
        }
        return translations;
    }
Zum Vergrößern anklicken....

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

Bezüglich der print Methode, hab ich das jetzt so umgesetzt :
Code: 
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 :
Code: 
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 ?
 

Aktuelle Jobs

Neue Themen

Ähnliche Themen

Fluessigkeit in Java3D modellieren bzw. realisieren
Antworten: 4
DFA in SQL Modellieren
Antworten: 3
Modellieren Haareschneiden
Antworten: 87
Modellieren eines Buchungssystems für Busfahrkarten
Antworten: 53
Rest - Bilder mit Metadaten modellieren
Antworten: 24

Zurück
Oben