# Datei schreiben - Sonderzeichen beachten?



## Jellysheep (4. Mai 2010)

Hi, 
ich möchte mehrere int- und char-Werte in eine Datei schreiben. 
1. Kann man in die Datei gleich ein int schreiben oder muss man das in zwei char aufspalten?
2. Zur eigentlichen Frage: Muss ich beachten, dass ich keine null-Zeichen etc. drinhabe? 
Backspace-Zeichen wären ja in einer Datei auch fehl am Platz... 
Zitat aus der Javadoc: 


> write(int b)
> Writes the specified byte to this buffered output stream.


Was ist gemeint? Byte oder int? Das ist doch nicht das gleiche.


----------



## vfl_freak (5. Mai 2010)

Moin,



Jellysheep hat gesagt.:


> ich möchte mehrere int- und char-Werte in eine Datei schreiben.
> 1. Kann man in die Datei gleich ein int schreiben oder muss man das in zwei char aufspalten?
> 2. Zur eigentlichen Frage: Muss ich beachten, dass ich keine null-Zeichen etc. drinhabe?
> Backspace-Zeichen wären ja in einer Datei auch fehl am Platz...
> ...



doch, im Prinzip schon 

Ein BYTE ist die Mengeneinheit für die Datenmenge von 8 bit (http://de.wikipedia.org/wiki/Byte)
INTEGER wiederum ist "nur" ein Datentyp (http://de.wikipedia.org/wiki/Integer_(Datentyp))

Wenn Du mal eine Blick in eine ASCII-Tabelle wirfst, dann siehst bspw. folgendes : Du kannst das Zeichen 'A' als CHAR ansehen oder als BYTE mit dem Wert 0x41 (oder dezimal 65) !
Gleiches gilt für integer-Werte: der Integer-Wert '5' hat als BYTE betrachte den Wert 0x35 (dezimal dann halt 53) !

Da ist letztlich alles eine Frage der Betrachtungsweise resp. Interpretation des jeweiligen BYTE in Deinem Code ....

Gruß
Klaus


----------



## Anime-Otaku (5. Mai 2010)

1.

Wenn da steht byte, schreibt man damit ein byte 

Der int-Wert repräsentiert dabei sozusagen das byte. Hört sich komisch an, ist aber so. Dabei interessiert nur der Wertebereich 0-255 (1. Byte von den 4 Bytes).  Man hat daher nicht das "Problem", dass man mit minus Zahlen rumhantieren muss.

Man kann das int dann einfach zu einem byte caste, um es als byte zu haben.

Aber generell empfiehlt sich ein byte[] zum schreiben zu nehmen. Damit man mehr auf einmal rausschreibt 

2. Wenn du nur bytes hast sind die repräsentierten Zeichen dem writer unbekannt (egal).
Wie liegen die Daten vor, die du rausschreiben willst?

P.S.: Was ist ein "Backspace-Zeichen"? oO


----------



## youza (5. Mai 2010)

Warum schreibst du nicht alles als Strings?
du kannst ja Chars sowie auch Integer Werte ohne Probleme in Strings umwandeln.
Ich löse es dann so das ich die Strings in ein Array schreibe und anschließend an eine Schreiber Klasse übergebe.


```
import java.io.FileWriter;
import java.io.IOException;


public class Schreiber{
	
	public void schreiben(String Daten[],String Datei){
		FileWriter fw2;
		try {
			fw2 = new FileWriter(Datei);
			for (int i = 0; i < Daten.length; i++) 
			{
				if(Daten[i]==null||Daten[i].isEmpty())
				{}
				else
				{
					fw2.write(Zeichenaendern(Daten[i]));
					fw2.write("\n");
				}
			}	
			fw2.close();
		} catch (IOException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
		
	}
	public String Zeichenaendern(String Temp)
	{
		String [] Replacer = new String[]{" ","'"};
		for (int i = 0; i < Replacer.length; i++) {
			Temp.replace(Replacer[i], "");
		}
		return Temp;
	}
}
```
Zum test:

```
import java.util.ArrayList;


public class Main {
	public static void main(String[]args)
	{
		String Datei = "output.txt";
		int i_Werte[] = new int[10];
		i_Werte[0] = 1;
		i_Werte[1] = 2;
		i_Werte[2] = 3;
		i_Werte[3] = 4;
		i_Werte[4] = 5;
		i_Werte[5] = 6;
		i_Werte[6] = 7;
		i_Werte[7] = 8;
		i_Werte[8] = 9;
		i_Werte[9] = 0;
		char c_Werte[] = new char[10];
		c_Werte[0] = 'h';
		c_Werte[1] = 'i';
		c_Werte[2] = 'l';
		c_Werte[3] = 'f';
		c_Werte[4] = 't';
		c_Werte[5] = ' ';
		c_Werte[6] = 'd';
		c_Werte[7] = 'a';
		c_Werte[8] = 's';
		c_Werte[9] = '?';

		ArrayList<String> al_Daten = new ArrayList<String>();
		for (int i = 0; i < i_Werte.length; i++) 
		{
			al_Daten.add(String.valueOf(i_Werte[i]));
		}
		for (int i = 0; i < c_Werte.length; i++) 
		{
			al_Daten.add(String.valueOf(c_Werte[i]));
		}
		String []Daten = new String[al_Daten.size()];
		for (int i = 0; i < Daten.length; i++) {
			Daten[i] = al_Daten.get(i);
		}
		Schreiber sch = new Schreiber();
		sch.schreiben(Daten, Datei);
	}
}
```


----------



## Jellysheep (5. Mai 2010)

Oh, gleich so viele Antworten!  Dankeschön! 

@vfl_freak & Anime-Otaku:
Ok, jetzt habe ich auch die Funktion write(int) verstanden. 

@Anime-Otaku:


Anime-Otaku hat gesagt.:


> 2. Wenn du nur bytes hast sind die repräsentierten Zeichen dem writer unbekannt (egal).


Ok, das klärt auch eine Frage.  Dem System ist der Inhalt der Datei auch egal? 


> Was ist ein "Backspace-Zeichen"? oO


Es gibt ein extra Zeichen für die Entfernen-Taste (eines der ersten zehn Zeichen der ASCII-Tabelle, meine ich) und für die Backspace-Taste glaube ich auch... 

@youza:
Das ist auch eine gute Lösung, braucht aber auch viel Platz (zB für die Zahl "23" werden zwei bytes verbraucht). 
Ich wollte das so schreiben, dass z.B. die Zahl 65 als "A" in die Datei geschrieben wird. 
Ich dachte nur, dass man auf Sonderzeichen achten muss...
Generell wollte ich das für ein eigenes, sehr kompaktes Dateiformat verwenden. 

[EDIT]
Ich hab es ausprobiert, die Speicherung der ersten fünfzehn Zeichen der ASCII-Tabelle und das Einlesen davon sind kein Problem. 
Auch wenn für die ersten 17 Zeichen etwas sehr seltsames in der Datei steht.


----------



## Jellysheep (8. Mai 2010)

So, ich hab doch noch eine Frage. 
Ein Wert zwischen 0 und 255 sollte in einer Datei gespeichert werden, eigentlich passt das in genau ein Zeichen bzw. Byte rein. 
Wenn ich den Wert auf ein (Java-)Byte caste, habe ich Werte von -127 bis 128. 
Wie speichere ich dann diesen Wert?


----------



## Jellysheep (8. Mai 2010)

*push*

Wie schreibe ich einen Wert von 0 bis 255 so klein wie möglich in eine Datei?
Beim Speichern eines Bytes wird immer am 128 abgeschnitten...


----------



## zerix (8. Mai 2010)

Hallo,

wenn du die Zahl als byte in die Datei schreibst, ist es egal wie Java die Zahl interpretiert, da die Bits die geschrieben werden die gleichen sind. 
Bsp:

signed byte = -1 -> 1111 1111
unsigned byte = 255 -> 1111 1111

Wenn du beispielsweise versuchst einen Integer-Wert mit 255 in ein Byte castest, steht darin -1.


Gruß

Sascha

EDIT:
Wenn du die Zahl 255 speichern möchtest, kannst du es nicht mit byte machen, da dann jede Ziffer durch ein Zeichen ist und jedes Zeichen durch ein byte dargestellt wird.


----------



## Jellysheep (10. Mai 2010)

Ah ok. Danke für die Erklärung. 
Ich  caste jetzt beim Einlesen einfach auf ein char, dann habe ich den  gewünschten Wert. 

Das  Problem habe ich inzwischen auch gefunden, es liegt an der Klasse  BufferedReader.


----------

