Textdatei einlesen

[Conax]

Ich habe mir mal den Code angeschaut um textdateien einzulesen. Das Programm soll einfach die textdatei zeile für zeile einlesen und dabei an jedes wort die Zahl von 1 bis 100 anhängen anhängen:

// Eine Datei wird zeichenweise abgearbeitet
import java.io.*;

public class Testzz {
  public static void main(String[] args) {
    // Einlesen des Dateinamens
    System.err.print("Dateiname?:");
    String dateiName = null;
    try 
    {
      // Dateiname : Vgl. Beispiel Anfang Kap. 5
      BufferedReader b = new BufferedReader(new InputStreamReader(System.in));
      dateiName = b.readLine();
    } 
      catch (IOException e) 
    {
      System.err.println(e);
      return;
    }
     System.err.println("Dateiname= " + dateiName);

     // Oeffnen der Datei. Vorsicht: es koennte keine
     // Datei mit dem o.a. Namen existieren.
     BufferedReader b = null;
     try 
    {
      b = new BufferedReader(new FileReader(dateiName));
    } 
      catch (FileNotFoundException io) 
    {
      System.err.println("Datei " + dateiName + " nicht gefunden.");
      return;
    }

    // Lesen der Zeichen der Datei.
    int ch;
    for(int f = 1; f <= 100; f++)
    {
    try  
    {
      while ((ch = b.read()) != -1) 
    {
        System.out.print((char) ch);
    }
      b.close();
    } 
    catch (IOException e) 
    {
      System.err.println(e);
      return;            
    }
    
    
    	System.out.println(ch + f);
    
    }
  }
}

Wenn also in den Textdatei z.B. das Wort Apfel steht soll er dann in der Ausgabe Apfel1 Apfel2 Apfel3 .... Apfel 100 ausgeben. Deswegen habe ich das ja auch versucht in eine Schleife reinzupacken was aber wohl nicht ganz geklappt hat

 

[bERt0r]

Was du machst, ist zu versuchen, 100 mal deine gesammte Datei auszulesen und auszugeben. Wenn du schon mal von Struktogrammen/Ablaufdiagrammen gehört hast, hilfts dir vielleicht das ganze mal aufzuzeichnen.

Für den fall, dass in Deiner datei nur ein Wort steht, und du an das dann die Zahl anhängen willst, genügt es, erst das Wort einzulesen (ein mal), in einer Variable zu speichern und dann in einer Schleife inklusive einer Zahl auszugeben.

 

[Conax]

Ne bin noch blutiger anfänger habe noch nichts von stuktogrammen gehört. Die Textdatei enthält mehrere Wörter.

 

[obb]

Ich hab mich mal drangesetzt und das gemacht:

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

public class Textzz {

	// Datei, die ausgelesen wird
	private static File file;
	
	// Diese Reader sind am Auslesen der Datei beteiligt
	private static FileReader fileReader;
	private static BufferedReader bufferedFileReader;
	
	// Gesamter Inhalt der Datei
	private static String fileContent = "";
	
	// Ein Array mit den Zeilen der Datei
	private static String[] lines;
	
	public static void main(String[] args) {
		init();
		getFileContent();
		getLines();
		printWords();
	}

	// Initialisierung der am Auslesen beteiligten Reader
	private static void init() {
		String fileName = getFileName();
		file = new File(fileName);
		try {
			fileReader = new FileReader(file);
		} catch (FileNotFoundException e) {
			System.err.println("Die Datei wurde unter dem angegebenen " +
							   "Pfad nicht gefunden.");
		}
		bufferedFileReader = new BufferedReader(fileReader);
	}
	
	// Auslesen des Dateinamens von der Standardeingabe (Konsole)
	private static String getFileName() {
		InputStream standardInputStream = System.in;
		InputStreamReader standardInputStreamReader = 
			new InputStreamReader(standardInputStream);
		BufferedReader bufferedStandardInputStreamReader =
			new BufferedReader(standardInputStreamReader);
		
		String fileName = null;
		System.out.print("Dateiname: ");
		try {
			fileName = bufferedStandardInputStreamReader.readLine();
		} catch (IOException e) {
			System.err.println("Fehler bei der Eingabe des Dateinamens.");
		}
		
		return fileName;
	}
	
	// Auslesen des Dateiinhalts
	private static void getFileContent() {
		String currentLine;
		try {
			// Der Dateiinhalt wird zeilenweise ausgelesen
			// Jede Zeile wird an den String mit dem Dateiinhalt angehängt
			// Das "\n" signalisiert einen Zeilenumbruch
			while((currentLine = bufferedFileReader.readLine()) != null)
				fileContent = fileContent + currentLine + "\n";
		} catch (IOException e) {
			System.err.println("Fehler beim Lesen der Datei.");
		}
	}
	
	// Auslesen der einzelnen Zeilen der Datei
	private static void getLines() {
		// Wir splitten den String überall wo sich ein Zeilenumbruch befindet
		lines = fileContent.split("\n");
	}
	
	// Auslesen der Wörter in den einzelnen Zeilen der Datei
	// und Ausgabe des gewünschten Textmusters auf der Standardausgabe
	private static void printWords() {
		String currentLine;
		String[] currentWords;
		int numberOfLines = lines.length;
		int numberOfWords;
		String currentWord;
		
		// Zeilenweises Durchlaufen der Datei und Extrahieren der Wörter aus
		// einer Zeile (jede Zeile wird dort gesplittet, wo sich ein
		// Leerzeichen befindet)
		for(int i = 0; i < numberOfLines; i++) {
			currentLine = lines[i];
			currentWords = currentLine.split(" ");
			numberOfWords = currentWords.length;
			
			// Jedes Wort wird nun in der gewünschten Form ausgegeben.
			for(int j = 0; j < numberOfWords; j++) {
				currentWord = currentWords[j];
				for(int k = 1; k < 100; k++)
					System.out.print(currentWord + k + ", ");
				System.out.print(currentWord + 100 + ".\n\n");
			}
		}
	}
}

Lass dich von der Länge des Codes nicht abschrecken. Ich habe versucht es wirklich Schritt für Schritt und möglichst klar herunterzuprogrammieren. Was die einzelnen Codeabschnitte tun, sollte aus den Kommentaren hervorgehen.​

Um die einzelnen Wörter mit den jeweiligen Zahlen auszugeben brauchst Du eine verschachtelte for-Schleife: Mit der äußeren Schleife gehst du die Wörter in der Datei durch. In der inneren Schleife gibst du dann das aktuelle Wort gefolgt von den Zahlen von 1 bis 100 aus.​

Noch eine Anmerkung:

System.err

verwendet man nur, um Fehlermeldungen auf der Standardausgabe auszugeben. Alles andere ist schlechter Stil. Also lieber

System.out

für die Ausgabe von Text verwenden.​

 

[Spacerat]

Ich hab mich mal drangesetzt und das gemacht:

...und ich dies

import java.io.FileReader;
import java.io.StreamTokenizer;
import java.util.Map;
import java.util.TreeMap;

public final class CountWords
{
	public static void main(String[] args)
	throws Throwable
	{
		final Map<String, IntHolder> wordStats = new TreeMap<String, IntHolder>()
		{
			private static final long serialVersionUID = 1L;

			@Override
			public String toString()
			{
				StringBuilder sb = new StringBuilder();
				for(Map.Entry<String, IntHolder> e : entrySet()) {
					sb.append(e.getKey());
					sb.append(": ");
					sb.append(e.getValue());
					sb.append("\n");
				}
				return sb.toString();
			}
		};
		StreamTokenizer st = new StreamTokenizer(new FileReader("./test.txt"));
		st.ordinaryChar('.');
		int token;
		do {
			if((token = st.nextToken()) == StreamTokenizer.TT_WORD) {
				if(!wordStats.containsKey(st.sval)) {
					wordStats.put(st.sval, new IntHolder());
				}
				wordStats.get(st.sval).value++;
			}
		} while(token != StreamTokenizer.TT_EOF);
		System.out.println(wordStats);
	}

	private static final class IntHolder
	{
		private int value;

		private IntHolder()
		{
			// nothing
		}

		@Override
		public String toString()
		{
			return String.valueOf(value);
		}
	}
}

@obb: Lass dich von den wenigen Zeilen nicht schrecken.
@TS: Möglicherweise müssen auch noch andere Zeichen als ordinary- bzw. wordChars markiert werden, wenn man z.B. auch Zahlen mitzählen will. Ich hoffe, dass das Lesen der Datei nicht zeilenweise geschieht, macht keine Umstände.

 

[Conax]

Vielen Dank. Ich seh schon einfache Aufgaben werden sehr schnell sehr komplex.

 

[Spacerat]

Naja, ich finde nicht, dass mein Code-Schnipsel sehr komplex ist. Wenn man erstmal mit der Standard-API vertraut ist, genügen halt 57 Zeilen um deine Aufgabe annähernd zu lösen. Natürlich ist mir klar, das man als "blutiger Anfänger" Klassen wie den StreamTokenizer und TreeMap noch nicht unbedingt kennt.
Aber kannst mein Schnipsel ja mal nachvollziehen. Es zählt nicht nur die Wörter, sondern fügt sie auch gleich nach Alphabet sortiert in die TreeMap ein - ist halt der Vorzug der TreeMap. Einziges Manko des Tokenizers ist dabei eigentlich nur, dass die Festlegung der Character ein wenig unhandlich ist, ganz besonders, wenn man "parseNumbers()" verwendet hat und plötzlich auch Zahlen in Strings haben will.

 

[Conax]

Ich habe jetzt java seit einer Woche (Brückenkurs). Ich werde Wirtschaftsinformatik studieren und habe dafür den Brückenkurs besucht: Brückenkurs Informatik

Es ging halt bisher hauptsächlich um Themen wie Schleifen und arrays. Welche Lektüre empfiehlt sich da eigentlich für absolute Anfänger (bzw. womit hatte vielleicht der ein oder andere hier gute Erfahrung gemacht)?

 

[Spacerat]

Eine stets hier empfohlene Lektüre int z.B. eben jene "Insel", welche bereits im Dokument deinem Link folgend vorhanden ist. Eine weitere wäre aus meiner Sicht noch das Javabuch von Guido Krüger und Thomas Stark.