Problem beim Auslesen aus File

[Dulin]

Liebe Community,

ich bin noch ziemlicher Neuling in Java und hoffe hier, Hilfe zu finden.

Und zwar habe ich eine Textdatei, die ausgelesen werden soll. Der Inhalt wird erst mal auf der Konsole ausgegeben.
In dieser Textdatei befinden sich mehrere Wörter, die mit Leerzeichen, aber auch mit anderen Zeichen voneinander getrennt sind. Diese Zeichen gilt es, in Leerzeichen umzuwandeln.
So weit so gut, das klappt wunderbar.
Jetzt soll der Ausgabestrom nach Wörtern getrennt werden, sprich jedes Wort mit Zeilenumbruch als Trennung in ein Array cbuf[] geschrieben werden.
Hier liegt mein Problem: Die Wörter werden zwar getrennt, allerdings habe ich nach jedem Buchstaben sehr viele Leerzeichen - um genau zu sein, so viele wie das cbuf[]-Array Indexe hat. Ich habe keine Ahnung, woran das liegen könnte und ersuche euch daher um Rat.

Argumente der Main-Methode sind: Name der Ein- und Ausgabedatei.

Klasse Control mit Main-Methode

/**
 * Steuert den Programmablauf
 */

import java.io.*;
import java.util.*;

public class Control{
    private static String inputFileName = null;    // Name der Input-Datei
    private static String outputFileName = null;   // Name der Output-Datei

    /**
     * Nimmt die einzulesende Textdatei auf und verwaltet den Vorgang des
     * Programmes.
     * Erstellt anschließend die Ausgabedatei.
     */
    public static void runtime(){
        try{
            // Aufbau der Reader-Kette
            FileReader FR = new FileReader(inputFileName);          // Datei auslesen
            SpaceFilterReader SFR = new SpaceFilterReader(FR);      // Sonderzeichen filtern
            WordFilterReader WFR = new WordFilterReader(SFR);       // Wörter bilden
            
            TreeMap<Integer, String> WordMap = new TreeMap<Integer, String>();

            // Buffergröße bestimmen
            char cbuf[] = new char[500];                // Buffer-Variable
            char character;                             // Alle Zeichen, in Wörter aufgeteilt

            // Solange lesen, bis das Ende der Datei erreicht wird
            while(WFR.ready()){
                String word = null;
                character = (char)WFR.read(cbuf, 0, cbuf.length);
                word = new String(cbuf);
                
                System.out.println(word);
                if(character == '\n'){
                    WordMap.put(1, word);
                }

            }
        }
        catch(IOException e){
            System.out.println(e+" - Die Datei konnte nicht geöffnet werden.");
        }
    }
    
    /**
     * Steuert den gesamten Ablauf des Programms
     * @param args the command line arguments
     */
    public static void main(String[] args) throws IOException{

        try{
            if(args.length == 0)        // Prüfen, ob -i=<infilename> keinen Wert enthält.
                throw new IOException("Es muss mindestens der Name der Input-Datei eingegeben werden!");
            else{                       // Dateinamen zuweisen
                inputFileName = args[0].substring(3);
                runtime();
            }
                
        }
        catch(IOException ex){
            System.out.println("Bla: "+ex);
        }
    }
}

Klasse SpaceFilterReader - Wandelt Zeichen (außer: 0-9, a-z, A-Z, Umlaute) in Leerzeichen um

import java.io.*;
/**
 * Wandelt alles außer Buchstaben, Umlaute und Zeichen in Leerzeichen um.
 */
public class SpaceFilterReader extends FilterReader{

    public SpaceFilterReader(Reader in){
        super(in);
    }

    /**
     * Filtert die Zeichen zu Leerzeichen
     * @return zeichen, das konvertierte Zeichen
     */
    @Override
    public int read() throws IOException{
        int character = 0;                // Das Zeichen, welches gelesen wird
        try{
            character = this.in.read();   // Besorgt ein Zeichen
      
            if(character == -1)           // Prüfen, ob die Datei zu ende ist.
                return character;
            
            // Sonderzeichen abfragen und umwandeln
            if    ((char)character >= '!' && (char)character < '0') character = ' ';
            else if((char)character > '9' && (char)character < 'A') character = ' ';
            else if((char)character > 'Z' && (char)character < 'a') character = ' ';

            // Umlaute abfragen und Zeichen zurückliefern.
            else if((char)character == 'ü' || (char)character == 'Ü' ||
                    (char)character == 'ä' || (char)character == 'Ä' ||
                    (char)character == 'ö' || (char)character == 'Ö') return character;
            else if(character == 225) return character;

            // Nachdem die Umlaute geprüft sind, werden alle weiteren Zeichen hinter z geprüft.
            else if((char)character > 'z') character = ' ';
        }
        catch(IOException e){
            System.out.println("Ein Fehler ist aufgetreten: "+e);
        }
        return character;
    }
}

Klasse WordFilterReader - Trennt den Strom nach Worten

import java.io.*;
/**
 * Trennt den Eingabestrom nach Worten.
 * Trennung erfolgt bei jedem Zeichen kleiner oder gleich dem Leerzeichen.
 */
public class WordFilterReader extends FilterReader {

    WordFilterReader(Reader in){
        super(in);
    }

    /**
     * Liest Zeichen aus einem Dokument und speichert diese wortweise im cbuf[]. Ersetzt hierbei
     * alle Zeichen kleiner oder gleich dem Leerzeichen mit einem Zeilenumbruch.
     * @param cbuf, ein zusammengesetztes Wort
     * @param off, Ab wo gelesen werden soll
     * @param len, Max. Anzahl an Zeichen, die ausgelesen werden sollen
     * @return amountOfChars, die Anzahl der gelesenen Zeichen
     */
    @Override
    public int read(char cbuf[], int off, int len) throws IOException{
        int character = 0;                   // Aktuell gelesenes Zeichen

        try{
            // Zeichen von der Position off aus bis len durchlaufen
            for(int amount = off; amount < len;){
                character = this.in.read();

                // Prüfen, ob Ende der Datei erreicht ist.
                if(character == -1)
                    return character;

                // Zeichen <= Leer durch Zeilenumbruch ersetzen und zurückliefern
                else if(character <= ' '){
                    character = '\n';
                    cbuf[amount] = (char)character;     // Einfügen in's Array
                    amount++;                           // Schleifenzähler heraufsetzen
                }
                
                // Wenn das Zeichen kein Leerzecihen ist:
                else if(character > ' '){
                    cbuf[amount] = (char)character;      // Einfügen in's Array
                    amount++;                            // Schleifenzähler heraufsetzen
                }

                return character;
            }
        }
        catch(IOException e){
            System.out.println("Fehler: "+e);
        }
        return character;
    }
}

 

[Dulin]

Ich habe den Fehler gefunden: Klasse WordFilterReader, Zeile 46.
Aufgrund des Returns wird die Methode beendet, wordurch die Wörter nicht vollständig gebildet werden können.

Ich lasse den Thread aber mal auf, falls noch weitere Fragen auftauchen. Danke schonmal an diejenigen, die bisher drübergeschaut haben.

 

[Michael...]

Hab den Code nur mal schnell überflogen:
- Musst Du das so machen?
- Von SpaceFilterReader wird zwar ein Objekt erzeugt, aber nie genutzt (sofern ich da nicht was übersehen habe)
- In WordFilterReader überschreibst Du die Methode

public int read(char[], int, int)

die in der ursprünglichen Form und laut Deiner Doku-Kommentare eigentlich die Anzahl der eingelesenen Zeichen zurückliefern soll. Deine Variante liefert aber im Erfolgsfall das erste eingelesene Zeichen zurück. Ohnehin wird nur das erste Feld von

cbuf

befüllt, da aufgrund von Zeile 46

return character;

die for-Schleife und die Methode auf jeden Fall im ersten Durchlauf beendet wird.
- und alles mit dem Key 1 in die TreeMap stecken zu wollen

WordMap.put(1, word);

ist vermutlich auch nicht Absicht!?

So ganz hab ich das noch nicht geblickt wie das laufen soll.

Wenn ich sowas machen müsste, würde ich das txt-File einfach per BufferedReader zeilenweise einlesen, dann mittels Sting#split() und einem entsprechenden regulären Ausdruck jede Zeile in ihre Worte zerlegen, die ich dann in eine Liste stecke bzw. in die Ausgabedatei schreibe.
Wären geschätzt so um die zehn Zeilen Code.

 

[Dulin]

Hi Michael,

danke für deine Antwort.
- Jap, das muss leider so.
- SpaceFilterReader wird genutzt, da der Zeiger in WordFilterReader darauf zeigt.
- Ja, die Rückgabe ist eigentlich sinnlos. Durch die Methode wird das cbuf[]-Array beeinflusst. Da es aus Control übergeben wird, muss es nicht von der Methode zurückgeliefert werden.

Die Ausgabe funktioniert aber soweit. Jetzt muss ich die Wörter noch zählen und entsprechend ihrer Häufigkeit sortieren.
Dafür habe ich eine neue Klasse "WordSorter" erstellt, die eine verkettete Liste mit je einem Wort pro Index bekommt und anschließend zählen und sortieren soll.

Mein Problem ist jetzt, dass ich die Wörter nach ihrer Zählung mit ihrer Häufigkeit in einer TreeMap<String, Integer> speichere (weil diese gleiche Indexe aussortiert => Dopplungen werden eliminiert) und nicht weiß, wie ich diese nach Anzahl sortieren kann...
Es gibt ja noch die Collections.sort()-Methode, allerdings benötige ich dafür ja eine Liste, die mir aber keine doppelten Indexes erlaubt... Die sortierte Liste sollte dann auch zurückgegeben werden (nicht die Map, wie es jetzt im Quellcode der Fall ist).

Die Ausgabe sollte nachher wie folgt aussehen:
4 Katze
3 Auto
3 Wurst
1 Lecker
1 blubb
1 ... etc

Hier nochmal der aktuelle Stand des Quellcodes:

/**
 * Steuert den Programmablauf
 */

import java.io.*;
import java.util.*;

public class Control{
    private static String inputFileName = null;    // Name der Input-Datei
    private static String outputFileName = null;   // Name der Output-Datei

    /**
     * Nimmt die einzulesende Textdatei auf und verwaltet den Vorgang des
     * Programmes.
     * Erstellt anschließend die Ausgabedatei.
     */
    public static void runtime(){
        try{
            // Aufbau der Reader-Kette
            FileReader FR = new FileReader(inputFileName);          // Datei auslesen
            SpaceFilterReader SFR = new SpaceFilterReader(FR);      // Sonderzeichen filtern
            WordFilterReader WFR = new WordFilterReader(SFR);       // Wörter bilden
            
            // Collection zum Unterbringen und Zählen der Wörter
            LinkedList<String> WordList = new LinkedList<String>();
            WordSorter WS;

            // Sonst. Variablen
            char character;                // Alle Zeichen, in Wörter aufgeteilt
            int wordCount = 0;             // Anzahl der Wörter
            String word = null;            // Aktuell ausgelesenes Wort

            /*
             * Da cbuf[] ein Referenzdatentyp ist, ist die Rückgabe des Arrays in der Methode WFR.read() nicht von Nöten,
             * da beide - Methode und SOS-Klasse - auf das Array referenzieren!
             */

            // Wörter auslesen und in Liste schreiben:
            while(WFR.ready()){                                         // Solange Lesen, bis Ende der Datei erreicht wird

                char cbuf[] = new char[200];                            // Buffer-Variable
                character = (char)WFR.read(cbuf, 0, cbuf.length);       // Wort auslesen
                word = new String(cbuf).trim();                         // Char-Array zum String umwandeln


                WordList.add(wordCount, word);                          // Wort in die TreeMap schreiben
                System.out.println("Index "+wordCount+": " + WordList.get(wordCount));
                wordCount++;
            }

            // Wörter nach Häufigkeit sortieren
            WS = new WordSorter(WordList);
            TreeMap <Integer, String> WordMap;
            WordMap = WS.sort();
        }
        catch(IOException e){
            System.out.println(e+" - Die Datei konnte nicht geöffnet werden.");
        }
    }
    
    /**
     * Steuert den gesamten Ablauf des Programms
     * @param args the command line arguments
     */
    public static void main(String[] args) throws IOException{

        try{
            if(args.length == 0)        // Prüfen, ob -i=<infilename> keinen Wert enthält.
                throw new IOException("Es muss mindestens der Name der Input-Datei eingegeben werden!");
            else{                       // Dateinamen zuweisen
                inputFileName = args[0].substring(3);
                runtime();
            }
                
        }
        catch(IOException ex){
            System.out.println("Bla: "+ex);
        }
    }

import java.util.*;
/**
 * Zählt die Wörter nach Häufigkeit auf und speichert sie in eine sortierende Collection.
 */
public class WordSorter {

    private LinkedList WordList;
    
    public WordSorter(LinkedList LiLi){
        WordList = LiLi;
    }

    /**
     * Sortiert eine Reihe von Wörtern nach Häufigkeit.
     * @param Liste von Wörtern
     * @return Nach Häufigkeit sortierte Map
     */
    public TreeMap sort(){
        String currentWord = null;  // Wort im Listenelement
        int wordCount = 0;          // Häufigkeit des Wortes
        
        TreeMap<String, Integer> WordMap = new TreeMap<String, Integer>();
        Iterator WordListIterator1 = WordList.iterator();                       // Iterator der äußeren Schleife

        // Gleichartige Wörter zählen
        while(WordListIterator1.hasNext()){                                     // Liste durchlaufen
            wordCount = 0;                                                      // Wortzähler auf Standardwert setzen.
            currentWord = WordListIterator1.next().toString();                  // Wort aus der Liste auslesen
            for(int listElement = 0;listElement < WordList.size(); listElement++){// Liste erneut durchlaufen und vergleichen
                if(currentWord.equals(WordList.get(listElement))){
                    wordCount++;                                                // Wenn Wort übereinstimmt: Häufigkeit++
                }
            }
            WordMap.put(currentWord, wordCount);                                // Wort, Häufigkeit in TreeMap speichern
        }

        System.out.println(WordMap.entrySet());
        System.out.println("Größe: "+WordMap.size());

        System.out.println(WordList.subList(0, WordList.size()));
        return WordMap;
    }
}