In einem String alle Eigennamen zählen

[Andy_93]

Hallo zusammen,

ich bin gerade dabei Java zu lernen und habe als Aufgabe bekommen einen englischen Text einzulesen und aus diesem alle Eigennamen und ihre jeweilige Häufigkeit zu speichern.

Folgende Reihenfolge für die Bearbeitung habe ich mir überlegt:
1. Text einlesen
2. Text so splitten, dass jedes Wort in einem String[] array gespeichert wird (mithilfe der .split()-Methode)
3. Durch den String[] array mit einer Schleife durchlaufen und dabei mit Hilfe eines RegEx (Regular Expression) prüfen, ob ein Wort überhaupt ein Eigenname ist, also mit einem Großbuchstaben beginnt. Außerdem muss ich ja darauf achten, dass nicht jedes groß geschriebene Wort ein Eigenname ist (z. B. das erste Wort am Satzanfang).
4. Ist ein Eigenname gefunden, diesen zuordnen und seine bisherige Häufigkeit um 1 erhöhen.

Die ersten 2 Schritte habe ich. Ich frage mich jetzt jedoch, wie ich alle Bedingungen im RegEx beachte und wie ich einen Eigenname so speichere, dass er bei einer Wiederholung um 1 erhöht wird.

Ich hoffe auf tatkräftige Unterstützung und Ideen

 

[Robat]

Für die Häufigkeit würde ich auf eine Map setzen wo du als Key den String hast und als Value, als int, die Anzahl der Vorkommen.

Zur Überprüfung würde ich kein Regex nehmen sondern mir immer nur den ersten Buchstaben des Strings anschauen (charAt) und prüfen ob es ein Großbuchstabe ist (Character#isUpperCase).
Ich würde auch nicht gleich am Leerzeichen splitten sondern erstmal die Sätze abtrennen (am Punkt splitten) und dann jeden Satz für sich bearbeiten. So kannst du leichter prüfen welches Wort am Anfang des Satzes steht.

 

[Andy_93]

Vielen, vielen Dank für Deine Antwort, Robat.

Dass es für meine Frage auch das Prinzip der Map gibt bzw. funktioniert, wusste ich bisher nicht. Ich habe mich aber über die Maps mal schlau gemacht und gelesen, dass es zwei verschiedene Maps gibt: TreeMap und HashMap. Ich denke, dass Du die HashMap meinst? Auf sie kann ich das übertragen, was Du mit dem String als Key und der Häufigkeit als Value meinst. Ist es dabei auch richtig, dass - so gesehen - jeder Eigennamen eine eigene ID bekommt, und wenn sich dann ein Eigenname wiederholt, die HashMap merkt, dass es das selbe Wort ist und entsprechend das bisherige Vorkommen um 1 erhöht?

Ich werde also zunächst an jedem Satzende (Punkt) splitten. Wenn ich dann jeden Satz einzeln berücksichtigen soll, würde ich jeden Satz dann in einzelne Worte splitten, sie in einem String[] Array speichern und ab dem zweiten Wort mit der Schleife beginnen (also an Position 1 des String[] Array)?

Statt des RegEx die Methode "isUpperCase" zu verwenden, ist gut. Sie gibt ja einen Boolean als Ergebnis zurück, der "True" ist, wenn das einzelne Wort mit einem Großbuchstaben beginnt. Nur dann soll ja das Wort in die HashMap aufgenommen werden. Also wäre das die Bedingung, die zu prüfen ist, bevor das Wort in die HashMap aufgenommen wird?
Sofern diese Bedingung erfüllt ist, muss man noch prüfen, wie ich nachgelesen habe, ob das Wort bereits in der HashMap enthalten ist. Dies kann ich mit der Methode "containsKey()" machen, oder? Anschließend kann ich das Wort entweder mit "put()" inzufügen oder es um eins erhöhen?

Was mir noch nicht ganz klar ist, ist wie ich mit der Map am Ende jedes Wort und seine Häufigkeit ausgeben kann. Kannst Du mir das bitte noch erläutern.

 

[Robat]

Ja genau ich meine HashMap

die Methode "isUpperCase" zu verwenden, ist gut. Sie gibt ja einen Boolean als Ergebnis zurück, der "True" ist, wenn das einzelne Wort mit einem Großbuchstaben beginnt.

Nicht ganz. Die Methode gibt true zurück wenn der übergebene char ein Großbuchstabe ist.

Also wäre das die Bedingung, die zu prüfen ist, bevor das Wort in die HashMap aufgenommen wird?

Ja

Dies kann ich mit der Methode "containsKey()" machen, oder? Anschließend kann ich das Wort entweder mit "put()" inzufügen oder es um eins erhöhen?

Kannst du so machen, ja

wie ich mit der Map am Ende jedes Wort und seine Häufigkeit ausgeben kann.

Eine HashMap besitzt eine Methode entrySet() welche ein Set<Map.Entry<K,V>> zurück gibt, über welches du iterieren kannst. Ungefähr so

for (Map.Entry<String, Integer> entry : map.entrySet()) {
   String key = entry.getKey();
   Integer value = entry.getValue();
   
}

 

[mihe7]

dass es zwei verschiedene Maps gibt: TreeMap und HashMap. Ich denke, dass Du die HashMap meinst? Auf sie kann ich das übertragen,

Kurz zum Verständnis: Map ist ein Interface, das das Verhalten von Objekten festlegt, die dieses Interface implementieren. Map ist geeignet, um Schlüssel-Werte-Paare abzubilden. Ein Schlüssel existiert in einer Map höchstens einmal und wird auf genau einen Wert abgebildet.

TreeMap und HashMap sind einfach zwei verschiedene Implementierungen des Map-Interfaces, die (neben vielen weiteren) in der Java-Standardbibliothek angeboten werden. Wenn Du mit den Methoden von Map auskommst (wie z. B. im konkreten Fall), dann spielt es für die Funktionalität i.d.R. keine Rolle, welche Implementierung Du wählst.

 

[Andy_93]

Vielen Dank für die Rückmeldung und Ergänzungen.
Ich bastel in den nächsten Tagen ein bisschen daran. Mal sehen ob´s klappt....

Kann ich die Daten, die dann in der HashTabelle gespeichert sind, eigtl auch visualisiert ausgeben, also in der Form einer Tabelle, in der bspw. in der ersten Spalte die Eigennamen stehen und in der zweiten Spalte ihre Häufigkeiten? Bisher weiß ich, dass es Java FX gibt und darin für Tabellen das "TableView".

 

[mihe7]

Du kannst mit den Objekten machen, was Du willst - z. B. in einer TableView anzeigen, als HTML rendern lassen, Diagramme anzeigen etc.

Hier etwas Code, den Du ggf. als Startpunkt nehmen kannst. Ich muss allerdings dazusagen, dass es evtl. weit bessere Lösungen gibt, weil sich meine JavaFX-Erfahrungen doch sehr in Grenzen halten.

Du musst lediglich dafür sorgen, dass in countWords die Variable data auf eine Map gesetzt wird, deren Einträge der Lösung Deiner Aufgabe entspricht (im Code werden einfach alle "Wörter" gezählt).

import java.util.*;
import java.util.stream.Stream;
import static java.util.stream.Collectors.*;
import javafx.application.Application;
import javafx.collections.ObservableListBase;
import javafx.geometry.Insets;
import javafx.geometry.Pos;
import javafx.scene.Scene;
import javafx.scene.control.*;
import javafx.scene.control.cell.PropertyValueFactory;
import javafx.scene.layout.HBox;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;

public class Test extends Application {
    static class MapList<K,V> extends ObservableListBase<Map.Entry<K,V>> {
        private Map<K,V> data;
        private List<K> keys = new ArrayList<>();

        public MapList(Map<K,V> data) {
            this.data = data;
            keys = data.keySet().stream().sorted().collect(toList());
        }

        public int size() { return keys.size(); }
        public Map.Entry<K,V> get(int ix) {
            K key = keys.get(ix);
            return new AbstractMap.SimpleImmutableEntry<K,V>(key, data.get(key));
        }
    }

    private MapList<String, Integer> countWords(String text) {
        Map<String, Integer> data = Stream.of(text.split(" "))
            .collect(groupingBy(String::toLowerCase, summingInt(s -> 1)));

        return new MapList<String, Integer>(data);
    }

    public void start(Stage stage) {
        final TextArea text = new TextArea();
        text.setPrefColumnCount(40);
        text.setPrefRowCount(5);

        final TableView<Map.Entry<String,Integer>> table = new TableView<>();
        TableColumn<Map.Entry<String,Integer>,String> keyCol = new TableColumn<>("Name");
        TableColumn<Map.Entry<String,Integer>,String> valueCol = new TableColumn<>("Anzahl");
        keyCol.setCellValueFactory(new PropertyValueFactory<Map.Entry<String,Integer>,String>("key"));
        valueCol.setCellValueFactory(new PropertyValueFactory<Map.Entry<String,Integer>,String>("value"));
        table.getColumns().add(keyCol);
        table.getColumns().add(valueCol);

        Button execute = new Button("Auswerten");
        execute.setOnAction(e -> table.setItems(countWords(text.getText())));

        HBox buttons = new HBox();
        buttons.setAlignment(Pos.CENTER);
        buttons.getChildren().add(execute);

        VBox root = new VBox(8);
        root.setPadding(new Insets(10,10,10,10));
        root.getChildren().add(text);
        root.getChildren().add(buttons);
        root.getChildren().add(table);
        stage.setScene(new Scene(root, 600, 400));
        stage.show();
    }

    public static void main(String[] args) {
        launch(args);
    }
}