# Binäre Datei lesen / schreiben



## Guest_JAVA (26. Jun 2012)

Hallo zusammen,

ich sitze seit Tagen an folgendem kniffligen Thema und komme nicht weiter:

Anforderung:
Ich habe als Ausgangsdatei eine Textdatei die wie folgt aufgebaut ist:


```
#12de
Ascii-Text ...
Ascii-Text ...
Binärer Block ( 1 Zeile )
Ascii-Text ...
Ascii-Text ...
#12de
#12de
Neuer Ascii-Text ...
Neuer Ascii-Text ...
Binärer Block ( 1 Zeile )
Neuer Ascii-Text ...
Neuer Ascii-Text ...
#12de
```

Die Datei ist in mehrere Blöcke aufgeteilt, jeder Block geht von #12de bis #12de.
Ich möchte in den normalen Textfeldern (Ascii-Text) eine Zahl suchen und den kompletten Block (von Start-#12de bis Ende-#12de) ausschneiden. Das funktioniert auch schon im groben!

Mein Problem ist jedoch, das der binäre Block beim lesen / schreiben immer kaputt geht!

Nun zu meiner Frage, wie kann ich zeilenweiße eine Binär-Datei lesen / Textblock auslesen / schreiben, ohne dass mir der binäre Teil kaputt geht?

Mein Quelltext sieht momentan wie folgt aus:


```
//Variablendeklaration
psn = "0123 123123123";
int last_12de = 0;
int pod_start = 0;
int pod_end = 0;
int j = 0;
boolean psn_found=false;
boolean stop=false;
String line_r = "";

ArrayList<String> img_line = new ArrayList<String>();

	File sourceFile = new File("/home/xxx/workdirectory_pod_gen/IMG.dat");
	File destFile = new File ("/home/xxx/workdirectory_pod_gen/OUT.txt");

	FileInputStream in;
	try {
	in = new FileInputStream(sourceFile);

	byte[] buffer = new byte[64]; // Das soll zeilenweise funktionieren
	for(int i; (i = in.read(buffer)) != -1 & (stop != true); ) 
	{
		line_r = new String(buffer, 0, i);

		//FileOutputStream os = new FileOutputStream(destFile);
	
		//Speichern Start / Ende
		if(line_r.contains("#12de"))
			last_12de = j;
			
		//Wenn Nummer gefunden, dann psn_found=true & Speicherung des Startwert zum Ausschneiden
		if(line_r.contains(psn))
		{
			psn_found=true;
			pod_start = last_12de;
		}
		//Wenn Nummer gefunden, dann Schleifenabbruch, sobald naechstes #12de gefunden
		//Speicherung des Endewert zum Ausschneiden
		if(psn_found)
		{
			if(line_r.contains("#12de"))
			{
				System.out.println("Nummer \"" + psn + "\" gefunden!");
				pod_end = last_12de;
				stop = true;
			}
		}
		//Schreiben der Datei in eine Arraylist
		img_line.add(line_r);
		j++;
	}
	
	System.out.println("POD-Start: " + pod_start + " -- POD-Ende: " + pod_end);
	
	for (int k = pod_start; k <= pod_end; k++)
	{
		System.out.println(img_line.get(k));
	}

	/*
	//Schreiben der Datei
	if (psn_found == true)
	{
		//Datei anlegen
		OutputStreamWriter dataWriter = new OutputStreamWriter(new FileOutputStream("/home/xxx/workdirectory_pod_gen/OUT.txt"));
		BufferedWriter bw = new BufferedWriter(dataWriter);
			
		//Datei fuellen
		for (int j = pod_start; j <= pod_end; j++)
		{
			System.out.println(img_line.get(j));
			bw.write(img_line.get(j) + "\n");
		}
		bw.close();
		return 0;
	}

*/
	} catch (FileNotFoundException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
return -1;
}
```


----------



## nillehammer (26. Jun 2012)

> Mein Problem ist jedoch, das der binäre Block beim lesen / schreiben immer kaputt geht!


Binär und Zeilenweise widersprechen sich. Entweder eine Datei ist Zeichenorientiert, dann kann sie mit Readern/Writern bearbeitet werden und es kann sowas geben, wie Zeilenende. Oder sie ist binär, dann wird sie mit Streams bearbeitet und es gibt sowas wie ein Zeilenende eben nicht. Das ist erstmal Fakt und ich glaube, das hast Du auch schon selbst rausgefunden.

Das Problem, binäre Daten in einem Textformat versenden zu wollen ist aber so generell, dass sich dazu schon Gedanken gemacht wurden. Das Zauberwort heißt en-/decodieren. Dabei werden Binäre Anteile so encodiert, dass sie in Text eingebettet werden können. Die beiden gängigsten Verfahren dazu sind entweder Hex-Encoding oder Base64-Encoding.

Wenn Du Einfluss auf die erstellung der Dateien hast, die Du verarbeiten musst, dann nutze eines dieser beiden Verfahren und Du kannst die komplette Datei mit BufferedInputReadern zeilenweise einlesen.


----------



## Guest_JAVA (27. Jun 2012)

Ich habe leider keinen Einfluss auf die Erstellung der Dateien.
Muss diese nur weiter verarbeiten.
Ob und wie diese Decodiert sind, weiß ich nicht. Könnte ich aber in Erfahrung bringen.

Aber:
Der binäre teil ist in einem Textdokument eingebettet, und ist genau eine Zeile lang.
Kann ich also davon ausgehen, dass dieser Teil dekodiert ist?

Das einlesen mittels BufferedInputReader werde ich testen, Rückmeldung folgt.
Danke schonmal bis hierhin!


----------



## nillehammer (27. Jun 2012)

> Aber:
> Der binäre teil ist in einem Textdokument eingebettet, und ist genau eine Zeile lang.
> Kann ich also davon ausgehen, dass dieser Teil dekodiert ist?


Wenn der Ersteller der Datei wusste, was er tut und nicht einfach nur die Bytes plump rausgeschrieben hat, kannst Du davon ausgehen, dass die Zeile *En*codiert ist. Du musst sie dann *de*codieren, um daraus wieder binäre Daten zu machen, die Du z.B. in ein byte-Array einliest. Was Du in Erfahrung bringen musst, ist das Verfahren, mit dem encodiert wurde. Denn, Du musst zum decodieren natürlich das selbe Verfahren einsetzen.

P.S. In meinem letzten Post hat sich ein Fehler eingeschlichen. Der Reader heißt natürlich korrekt *BufferedReader*. Das "Input" ist zu viel


----------



## Guest_JAVA (28. Jun 2012)

Muss ich diesen binären Teil denn eigentlich zwingend decodieren?
Ich möchte ja nichts daran ändern, sondern diesen Teil unverändert nach dem Auslesen wieder schreiben.

Ich habe das jetzt mal ohne versucht, hat leider nicht geklappt.
Binärteil ist wieder kaputt.



```
try {                                                                                                                                                                          
BufferedReader br = new BufferedReader(new FileReader("/home/xxx/workdirectory_pod_gen/in.dat"));                                                                                                             
BufferedWriter bw = new BufferedWriter(new FileWriter("/home/xxx/workdirectory_pod_gen/out.txt"));

while ((line_r = br.readLine()) != null) 
{ 
 bw.write(line_r);
 bw.newLine();
 System.out.println(line_r);   
}                                                                                                                                                               
}                                                                                                                                                                  
catch (IOException e) 
{             
System.err.println("Error: " + e);
}
```


----------



## Guest_JAVA (28. Jun 2012)

Achso, habe ich vergessen, line_r ist als String deklariert.


----------



## Guest_JAVA (2. Jul 2012)

- push -


----------



## SlaterB (2. Jul 2012)

Reader ist absolutes NO GO, und das kannst du mir dann auch glauben, 
im Gegensatz zum vermeintlichen 'Binär und Zeilenweise widersprechen sich.' von nillehammer 

natürlich ist es sehr schlimm, das zu vermischen, aber doch kein Ding der Unmöglichkeit,
mit Reader kommt man allerdings nicht weit, denn der verfälscht die Bytes beim Umformen in chars,
erstmal muss die Datei als bytes eingelesen werden wie du es im ersten Post wohl hast,

was dabei konkret deine Probleme sind ist nicht ganz erkennbar,
wie du vorzugehen hast kann ich aus der Ferne auch kaum sagen, 
du musst dir die Datei anschauen, die bytes die ankommen und dann daraus etwas lesen,

Zeilenumbruch gibt es wirklich nicht unbedingt, selbst wenn die Text-Zeilen welche haben sollten muss man damit rechnen,
dass bei den Binärdaten zufällig auch entsprechende Bytes dabei sind, also nicht blind darauf verlassen,

günstigerweise haben die Binärabschnitte spezielle eindeutige Token am Anfang und Ende, ansonsten kann kaum Sicherheit geben,
suche nach #12de wie du selber schon sagst, falls es nicht mit String klappt schau dir im Detail an wie es in Bytes aussieht


----------



## Guest_JAVA (2. Jul 2012)

Ok, also von dem zeilenweiße lesen bin ich jetzt weg. Das funktioniert nicht, wie Ihr schon gesagt habt.
Nun zu meinem Problem vor dem ich stehe:

Wie kann ich dann, wenn ich binär lese mir merken wo "#12de" steht?
Also den Teil den ich ausschneiden möchte?

Wäre es eine Textdatei würde ich es so machen:

```
1. <irgendetwas>
2. #12de
3. Ascii-Text
4. Binärer Zeilt
5. Asci-Text
6. gesuchte Nummer 0123456789
7. #12de
8. #12de
9. Neuer Block ....
10. ....
```

Gesuchte Nummer finde ich in Zeile 6, ich nehme das vorherige #12de und das darauffolgende (also Zeile 2 - 7 und schreibe diese Zeilen in eine neue Datei)

Könnte ich mit Zeilen arbeiten wäre das einfach.
Durch den binären Stream habe ich aber ja pro Schleifendurchlauf 64 byte (bzw. mittlerweile auf 1024 erhöht, was das Problem aber nicht vereinfacht.)
Da kann ich ja garnicht mehr wissen von wo bis wo ich ausschneiden muss?


----------



## SlaterB (2. Jul 2012)

von 'zeilenweiße' solltest du dich auch als Wort verabschieben, gruselig, zeilenweise heißt das

einen byte-Cache von 100.000 oder was auch immer ist glaube ich nicht ungewöhnlich in diesen Fällen,
ansonsten notfalls bei #12de anfangen und und alles danach erstmal wegspeichern, 
wenn du als Ende ein 100 byte langes Konstrukt suchst, dann vielleicht von den gecachten 1024 byte die letzten 99 behalten (bzw. sauberer nur die Hälfe wegschreiben),
mit weiteren auffüllen und dann weiter suchen, nicht dass 99 byte von den gesuchten 100 wegkommen und das eine fehlende byte danach auch keine Aussage hat,

usw., Probleme einzeln angehen und lösen, an Beispielen testen und genau auf den Grund gehen wenn glücklicherweise etwas nicht geht 
(glücklich in dem Sinne, dass ein Fehler im gedachten Code auffällt, der sonst vielleicht erst viel später Probleme macht)


----------

