# Einlesen von Bytes



## Frank the B. (20. Feb 2009)

Hallo,
also ich hab folgendes Problem und hoffe auf Eure Hilfe. I will von einer Datei Bytes einlesen, Messwerte von Sensoren. Nur leider gehen dabei Informationen verloren (ich gehe sogar von rund 2/3 Verlust aus). Das heißt also, dass ich nicht die gesamten Bytes bekomme, sondern immer nur ein paar. 
Kann es vielleicht sein, dass die Daten zu schnell reinkommen und Java das nicht gebacken bekommt? 
Hier mal Auszug meines Codes, nur dass Ihr seht, was ich nutz

```
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class ReadingErec {
	public static void main(String[] args){
		
		File file = new File(Hier kommt Pfad für Datei rein);
		FileInputStream fileInput = null;
		try {
			fileInput = new FileInputStream(file);
		} catch (FileNotFoundException e1) {
		}
		DataInputStream dataInput = new DataInputStream(fileInput);
		
		byte readByte = 0;
		String temp = null;
		int i = 0;
		
		byte[] oneDataSerieRead = new byte[64];
		String[] stringData = new String[64];
		try {
			readByte = dataInput.readByte();
		} catch (IOException e) {}

		while (readByte != 0){
...
```
Gibt es sonst auch eine Möglichkeit in Java einzelne Bits einzulesen? Ich weiß sonst nicht mehr weiter....
Bin für jede Hilfe dankbar 
MfG
Frank.


----------



## Generic1 (20. Feb 2009)

>>Kann es vielleicht sein, dass die Daten zu schnell reinkommen und Java das nicht gebacken bekommt? 

Das würd ich ausschließen,
Probier mal, den DataInputStream zu dekorieren mit einem BufferedInputStream


```
DataInputStream dataInput = new DataInputStream(fileInput);
```


----------



## Spacerat (20. Feb 2009)

Einzelne Bits...? Ist wohl ein Druckfehler (ist ja von Bytes die Rede), sonst wäre es 
	
	
	
	





```
DataInputStream.readBoolean()
```
Wenn mann den gesammten Stream allerdings in einem ByteArray haben will geht folgendes:
	
	
	
	





```
ByteArrayOutputStream cp = new ByteArrayOutputStream();
FileInputStream in = new FileInputStream(file);
int r;
while((r = in.read()) != -1) cp.write(r);
in.close();
cp.close();
byte[] read = cp.toByteArray();
```


----------



## tuxedo (20. Feb 2009)

Wobei letzteres nicht unüberlegt eingesetzt werden sollte. Bei zu großen Files kann man damit den zur Verfügung stehenden Speicher recht schnell sprengen...
Am Besten und nach Möglichkeit nur den Teil im Speicher halten der auch gerade im Speicher gebraucht wird.

- Alex


----------



## Frank the B. (20. Feb 2009)

hi nochmal,
na das ging ja schnell mit den Antworten vielen Dank .
Leider klappt nichts von dem. Habs mit dem BufferedInput versucht und auch mit dem ByteArray und da gibts denselben Fehler....
Gibts noch eine Möglichkeit??

ps: Ich hab in drei Foren nachgefragt und Ihr seid die Ersten, die antworten  VIelen Dank dafür.


----------



## tuxedo (20. Feb 2009)

Ähm, kannst du vllt. noch ein wenig mehr vom Code posten?

Was mich "verwirrt":


```
readByte = dataInput.readByte();
```

Du liest die Datei "byteweise", also ein byte nach dem anderen? Warum nicht blockweise? Und wo ist der Schleife die den Rest der Datei liest?

- Alex


----------



## Spacerat (20. Feb 2009)

Das hätte Klappen müssen... Da kommt mit Sicherheit irgendwo 'ne Exception (sprich Fehlermeldung). Davon bräuchte ich mal den Text...

BTW.: Tuxedo hat natürlich vollkommen Recht. Die Dateien sind hoffentlich nicht allzu gross.


----------



## Frank the B. (20. Feb 2009)

Also hier mal der Gesamte Code für die Klasse:

```
package readingErec;

import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Vector;

public class ReadingErec {
	
	File fileToOpen;
	FileInputStream fileInputForFileToOpen;
	DataInputStream dataInputStream;
	int oneByte;
	OnePackage onePackage = new OnePackage();
	
	
	public Vector<OnePackage> getFileToOpenAsVector(String pathToFile) throws IOException{
		
		Vector<OnePackage> output = new Vector<OnePackage>();
		
		fileToOpen = new File(pathToFile);
		System.out.println("Creating file...");
		
		fileInputForFileToOpen = new FileInputStream(fileToOpen);
		
		dataInputStream = new DataInputStream(fileInputForFileToOpen);
		System.out.println("Creating Stream...");
		int[] packet = new int[15];
		
		try{
			oneByte = dataInputStream.readUnsignedByte();
		} catch (Exception e){
		}
		System.out.println("Creating dataset...");
		while(dataInputStream.available() >= packet.length){
			if (oneByte == 255){
				for (int i = 0; i < packet.length; i++){
					packet[i] = dataInputStream.readUnsignedByte();
				}
				OnePackage temp = new OnePackage();
				temp.setPacket(packet);
				output.add(temp);
			}
		}
		return output;
	}
	public static void main(String[] args){
		ReadingErec erec = new ReadingErec();
		Vector<OnePackage> input = new Vector<OnePackage>();
		try {
			input = erec.getFileToOpenAsVector(Hier der Dateipfad);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		if (input.size() > 0)
			System.out.println("All complete...");
	}
}
```
Hier die Klasse OnePackage, die nur dafür ist, jeweils ein Datenpacket zu speichern. Als Klasse, damit ich Vector nehmen kann.

```
package readingErec;

public class OnePackage {
	private int[] packet;
	
	public OnePackage(){
		this.packet = new int[15];
	}

	public int[] getPacket() {
		return packet;
	}

	public void setPacket(int[] packet) {
		this.packet = packet;
	}
}
```

Kurze Erklärung:
Ich bekomm immer Datensätze von jeweils 16 byte, wobei ein Byte mit dem Wert 255 (0xff) Start- bzw. Endbyte ist. Speichern tu ich jeweils einen Block von 16 byte in dem int array package. alle packages speicher ich in dem Vector input in der main methode. input bekommt den vector output bei der Methode.
Hoffe Ihr könnt damit was anfangen.
ps: wie kann man bytes denn blockweise einlesen?
mfg


----------



## Spacerat (20. Feb 2009)

Also...
1. OnePackage kann eliminiert werden... Vector<int[]> funktioniert auch.
2. Möglicherweise Nebensache, aber "getFileToOpenAsVector" wird ohne "close()" auf die Streams verlassen.

```
public class ReadingErec
{
  public Vector<int[]> getFileToOpenAsVector(String pathtofile) throws IOException
  {
    Vector<int[]> rc = new Vector<int[]>();
    FileInputStream in = new FileInput(pathtofilename);
    int bt;
    int cnt = 0;
    int[] buf = new int[16];
    while((bt = in.read()) != -1) { // bis Datei-Ende lesen
      buf[cnt++] = bt & 0xFF;
      cnt %= 16;
      if(cnt == 0) {
        rc.add(buf);
        buf = new int[16];
      }
    }
    in.close();
    return rc;
  }

  public static void main(String args[])
  {
    Vector<int[]> packets = null;
    try {
      packets = getFileToOpenAsVector(pathtofile); // möglicherweise arg[0]
    } catch(IOException ioe) {
      ioe.printStackTrace();
    }
    if(packets != null) System.out.println("Success");
  }
}
```


----------



## Frank the B. (20. Feb 2009)

Hey ja Danke für den Code. So läufts und ich bekomm alles was ich will 
Vielen lieben, ich hoff ich kann das mal gut machen 
mfg


----------

