# Daten aus txt-datei einzeln nach Spalten einlesen



## Spoocky (17. Jul 2006)

Ich würde gerne aus einer txt-Datei einzelne Werte (Zahlen), die in dieser txt-Datei in Spalten angeordnet sind (zeilenweise durch Tabs getrennt), einlesen.
Habe schon daran gedacht, dieses byteweise zu versuchen, nur fehlt mir da noch die konkrete Idee und der Ansatz.

Ist es möglich, jedes einzelne Zeichen in einer solchen txt-Datei mit Hilfe der Stelle, an der dieses Zeichen innerhalb der Zeile steht, anzusprechen?

Vielen Danke schonmal...


----------



## SlaterB (17. Jul 2006)

sofern du nicht auf was fertiges hinauswillst,
sollte es wohl kaum Probleme bei einer eigenen Umsetzung geben,

Zeilenumbrüche erkennst du an \n, \r, \n\r oder sonst was ähnliches (Datei zeichenweise anschauen),
mit einen BufferedReader kannst du die Datei gleich zeilenweise einlesen,

dann entweder alle Zeichen selber zählen oder z.B. einen StringTokenizer einsetzen, der speziell nach Tabs trennen kann


----------



## Spoocky (17. Jul 2006)

ok, damit weiss ich, dass ich auf der richtigen spur bin.

mir ist noch nicht ganz klar wie der syntax bzw. der genaue aufbau ist, um an die einzelnen zeichen ranzukommen.

Womit muss ich die Datei öffen und wie zähle ich von zeichen zu zeichen?


----------



## SlaterB (17. Jul 2006)

also wie man eine Datei einliest erkläre ich hier nicht 

da gibts ja soviele Details dazu, da solltest du ein ganzes Tutorial zu lesen,
in Java-Insel stehts auf den ersten Blick bisschen kompliziert bzw. knapp (ohne BufferedReader)
http://www.galileocomputing.de/openbook/javainsel5/javainsel12_000.htm#Xxx999378
ion der FAQ gar nicht..,
aber hier hab ich noch ein Beispiel gefunden:
http://www.java-forum.org/de/viewtopic.php?t=32217

ansonsten zählen:
du hast Strings, da kannst du dir jedes Zeichen anschauen oder nach bestimmten Zeichenkette suchen, oder das ganze in ein char-Array umwandeln oder was immer du willst,

wenn du auch diese Befehle alle nicht kennst dann schaue dir z.B. die API zur Klasse String an,
http://java.sun.com/j2se/1.5.0/docs/api/


----------



## Spoocky (17. Jul 2006)

ich glaube, genau hier ist aber knackpunkt! Es wäre für mich wichtig, genau zu wissen, wie eine Datei zeichenweise eingelesen wird. Das wird mir einiges erleichtern.


----------



## The_S (17. Jul 2006)

Spoocky hat gesagt.:
			
		

> Es wäre für mich wichtig, genau zu wissen, wie eine Datei zeichenweise eingelesen wird.




```
StringBuilder datei = new StringBuilder();
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("datei.extension"));
int zeichen = 0;
while ((zeichen = bis.read()) != -1) {
   datei.append((char)zeichen);
}
bis.close();
```


----------



## Spoocky (17. Jul 2006)

Danke für den Code-Schnipsel. Er funktioniert auch ganz gut, nur kann man nicht jedes einzelne Zeichen ansprechen, das heisst, wenn man eine Datei, in der nach folgender Art Zahlen folgen [ 2.3445       4.6784     67.3244     23.4355  usw.] und diese auch untereinander angeordnet sind, man praktisch 10 Spalten hat, ist jetzt ds Ziel, die einzelnen Werte aus den Spalten 3, 6 und 7 aus der Datei zu lesen und nur diese Werte in den genannten Spalten.

Aber ich bin froh, dass ich hier dem Problem auf die Spur komme...


----------



## Murray (17. Jul 2006)

Die Datei hat also beliebig viele Zeilen, die jeweils genau 10  durch Whitespace getrennte Werte enthalten? Dann sollte man die Datei vielleicht besser zeilenweise lesen und die einzelnen Zeilen dann zerlegen:

```
BufferedReader in = new BufferedReader( new FileReader( "datei.ext"));
String line = null;
while((line = in.readLine()) != null)
{
   //---Zeile spaltenweise aufteilen
   String[] cols = line.split( "\\s+"); //--- regex "\s" -> whitespace char, qualifier "+" -> one ore more times

   //--- Spalten 3, 6 u. 7 extrahieren
   String col3 = cols[2];
   String col6 = cols[5];
   String col7 = cols[6];

   /* ... */

}
```


----------



## Guest (17. Jul 2006)

ich habe jetzt folgendes kleines programm:


```
import java.io.*;
public class lesen {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		BufferedReader in = new BufferedReader( new FileReader( "test.dat"));
		String line = null;
		while((line = in.readLine()) != null)
		{
		   //---Zeile spaltenweise aufteilen
		   String[] cols = line.split( "\\s+"); //--- regex "\s" -> whitespace char, qualifier "+" -> one ore more times

		   //--- Spalten 3, 6 u. 7 extrahieren
		   String col3 = cols[2];
		   String col6 = cols[5];
		   String col7 = cols[6];

		   /* ... */

		}
	}

}
```

bei dem folgende Fehler auftreten:

Exception in thread "main" java.lang.Error: Unresolved compilation problems: 
	Unhandled exception type FileNotFoundException
	Unhandled exception type IOException

	at lesen.main(lesen.java:9)

Ich habs jetzt fast geschafft, es müssen nur noch die letzten fehler behoben werden...


----------



## Murray (17. Jul 2006)

Und das ist sooo schwierig? Der Compiler meckert, dass hier zwei Exceptions nicht behandelt werden, die von irgendwelchen Anweisungen in diesem Code als sog. "checked Excpetions" deklariert worden sind. Damit soll sichergestellt werden, dass bestimmte fehlerträchtige Operationen wie hier das Öffnen einer Datei (deren Existenz ja erst zur Laufzeit geprüft werden kann) auch mit einer hinreichenden Fehlerbehandlung versehen werden.
Also z.B.:

```
import java.io.*;
public class lesen {

   public static void main(String[] args) {
      try {
        BufferedReader in = new BufferedReader( new FileReader( "test.dat"));
        String line = null;
        while((line = in.readLine()) != null)
        {
           //---Zeile spaltenweise aufteilen
           String[] cols = line.split( "\\s+"); //--- regex "\s" -> whitespace char, qualifier "+" -> one ore more times

           //--- Spalten 3, 6 u. 7 extrahieren
           String col3 = cols[2];
           String col6 = cols[5];
           String col7 = cols[6];

           /* ... */
        }
      } catch ( FileNotFoundException fe) {
         System.err.println( "Datei test.dat nicht gefunden");
         fe.printStackTrace();
      } catch ( IOException ie) {
         System.err.println( "Fehler beim Lesen der Datei test.dat");
         ie.printStackTrace();
      }
   }

}
```
/EDIT: code-tags
/EDIT2: kann mir jemand sagen, was hier klemmt? In der Vorschau werden die Code-Tags ausgewertet, und alles sieht gut aus, aber nach dem Absenden ist hier wieder alles unformatiert - ein Fall für die Admins, oder einfach schon zu spät??


----------



## Spoocky (17. Jul 2006)

ok, soweit geht das jetzt auch.

jetzt gibts nur noch ein letztes problem mit dieser zeile:


```
while((line = in.readLine()) != null)
```

hier ist die fehlermeldung "in cannot be resolved"

muss noch irgendetwas deklariert werden?


----------



## Murray (17. Jul 2006)

Seltsam - in wird doch zwei Zeilen darüber deklariert und intialisiert; zeig nochmal den aktuellen Code.


----------



## Spoocky (17. Jul 2006)

hier der aktuelle code:


```
import java.io.*;
public class lesen {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try {
		BufferedReader in = new BufferedReader(new FileReader( "test.dat"));
		
		} catch (Exception e) {System.out.println (" Fehler 002");
		}
		String line = null;
		while((line = in.readLine()) != null)
		{
		   //---Zeile spaltenweise aufteilen
		   String[] cols = line.split( "\\s+"); //--- regex "\s" -> whitespace char, qualifier "+" -> one ore more times

		   //--- Spalten 3, 6 u. 7 extrahieren
		   String col3 = cols[2];
		   String col6 = cols[5];
		   String col7 = cols[6];

		   /* ... */

		}
	}

}
```


----------



## Murray (17. Jul 2006)

Mit einem try-cachc-Block eröffnet man sozusagen einen neuen  Namensraum; alles, was darin deklariert wird, ist auch nur in diesem Block sichtbar.
Entweder schreibst Du das catch erst ganz am Ende, oder Du deklarierst die Variable in vor dem (ersten) try-catch-Block


----------



## Spoocky (17. Jul 2006)

```
import java.io.*;
public class lesen {

public static void main(String[] args) {
	try {
		BufferedReader in = new BufferedReader( new FileReader( "test.dat"));
		String line = null;
		while((line = in.readLine()) != null)
		{
			//---Zeile spaltenweise aufteilen
			String[] cols = line.split( "\\s+"); //--- regex "\s" -> whitespace char, qualifier "+" -> one ore more times

			//--- Spalten 3, 6 u. 7 extrahieren
			String col3 = cols[2];
			String col6 = cols[5];
			String col7 = cols[6];

			System.out.println (col3);

			/* ... */
		}
	} catch ( FileNotFoundException fe) {
		System.err.println( "Datei test.dat nicht gefunden");
		fe.printStackTrace();
		} catch ( IOException ie) {
			System.err.println( "Fehler beim Lesen der Datei test.dat");
			ie.printStackTrace();
			}
}

}
```

ok, soweit jetzt alles erstmal klar. Nur gibts jetzt ne neue Fehlermeldung:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 2
	at lesen.main(lesen.java:14)

Läuft da ne variable über?


----------



## Murray (17. Jul 2006)

Vermutlich ist dann in der Datei mindestens eine Zeile, die dem Spaltenformat nicht genügt. Die Exception kommt aus dem Zugriff auf das cols-Array. Lass Dir doch mal in der while-Schleife nach dem split mit

```
System.out.println( "line " + line + " -> " + cols.length + " cols");
```
die Anzahl der Spalten ausgeben.


----------



## Spoocky (18. Jul 2006)

perfekt. DANKE!!! Es funktioniert


----------

