Advanced   Java   Services
Lesen und Schreiben von Binärdateien
Back Next Up Home

Öffnen einer BinärDatei zum Lesen


Wir verwenden die Klasse FileInputStream. Will man einen gepufferten Zugriff, so verwendet man zusätzlich die Klasse BufferedInputStream. Beide Klassen sind reale Ableitungen der abstrakten Basisklasse InputStream (siehe Hierarchie der InputStreamklassen).

Die wichtigsten Konstruktoren der Klasse FileInputStream
FileInputStream(String fileName)
 
Creates a FileInputStream by opening a connection to an actual file, the file named by the path name in the file system.
FileInputStream(File file)
 
Creates a FileInputStream by opening a connection to an actual file, the file named by the File object file in the file system.

Die Konstruktoren der Klasse BufferedInputStream
BufferedInputStream(InputStream in)
 
 
 
Create a buffering byte-input stream that uses a default-sized input buffer.
Man muß schon den Quellcode lesen, um herauszufinden, wie groß "default-sized" ist. Dort finden man den folgenden Eintrag:
private static int defaultBufferSize = 8192;
BufferedInputStream(InputStream in, int sz) Create a buffering byte-input stream that uses an input buffer of the specified size.


Lesen einer Binärdatei


InputStream stellt drei Lesemethoden zum Einlesen von Binärdaten aus Dateien bereit.

Wichtige Methoden der Klasse InputStream
ReturntypName der Methode
abstract int
 
 
 
read()
Reads the next byte of data from the input stream. The value byte is returned as an int in the range 0 to 255. If no byte is available because the end of the stream has been reached, the value -1 is returned. This method blocks until input data is available, the end of the stream is detected, or an exception is thrown.
int
 
 
 
read(byte[] b)
Reads some number of bytes from the input stream and stores them into the buffer array b. The number of bytes actually read is returned as an integer. This method blocks until input data is available, end of file is detected, or an exception is thrown.
int
 
 
 
read(byte[] b, int off, int len)
Reads up to len bytes of data from the input stream into an array of bytes. An attempt is made to read as many as len bytes, but a smaller number may be read. The number of bytes actually read is returned as an integer. This method blocks until input data is available, end of file is detected, or an exception is thrown.
int
 
 
available()
Returns the number of bytes that can be read (or skipped over) from this input stream without blocking by the next caller of a method for this input stream.

Die letzten beiden read-Methoden stützen sich dabei auf die erste abstrakte Methode, wie ein Blick in den Quellcode zeigt.

Byte für byte einlesen mit int read()


FileInputStream fis = null;

try
{
   String fileName="ReadBinary.exe";
   File file = new File(fileName);
   fis = new FileInputStream(file);
   long size = file.length();
   byte[] data = new byte[(int)size);
   int by, i=0;
   while( (by=fis.read()) != -1 )
      data[i++] = (byte)by;

}
/*catch(FileNotFoundException ex)
{
   System.out.println(ex);
}*/
catch(IOException ex)
{
   System.out.println(ex);
}
finally
{
   if(fis!=null)
      try
      {
         fis.close();
      }
      catch(Exception ex)
      {
      }
}


Datei auf einmal lesen mit int read(byte[] buf)


FileInputStream fis = null;

try
{
   String text ;
   String fileName="TextDateiLesen2.java";
   File file = new File(fileName) ;
   long size = file.length() ;
   byte[] buf = new byte[(int)size] ;

   fis = new FileInputStream(file);
   fis.read(buf) ;
}
/*catch(FileNotFoundException ex)
{
   System.out.println(ex);
}*/
catch(IOException ex)
{
   System.out.println(ex);
}
finally
{
   if(fis!=null)
      try
      {
         fis.close();
      }
      catch(Exception ex)
      {
      }
}


Datei gepuffert einlesen mit BufferdInputStream


FileInputStream fis = null;
BufferedInputStream bis = null;

try
{
   String fileName="irgendeine.hexe";
   File file = new File(fileName) ;
   fis = new FileInputStream(file);
   bis = new BufferedInputStream(fis) ;
   //...
   //...
}
catch(...)
{
   //...
}
finally
{
   if(bis != null)
      try
      {
         bis.close();
      }
      catch(...)
      {
      }
   if(fis != null)
      try
      {
         fis.close();
      }
      catch(...)
      {
      }
      // Reihenfolge wichtig
}

oder kürzer


BufferedInputStream bis = null;

try
{
   String fileName="irgendeine.hexe";
   File file = new File(fileName) ;
   bis = new BufferedInputStream( new FileInputStream(file) ) ;
   //...
   //...
}
catch(...)
{
   //...
}
finally
{
   if (bis != null
      try
      {
         bis.close();
      }
      catch(...)
      {
      }
}


Realistische Einlesevorgänge, Verfügbare Hauptspeichergröße ermitteln

Die obigen Codefragmente zeigen lediglich die Basisschemata. Will man die ganze Datei in einem einzigen Array speichern, so sind einige Vorüberlegungen anzustellen. Hat die Datei in einem Array Platz und hat dieses Array wiederum Platz im Hauptspeicher? Da für die Größenangabe eines Arrays in Java höchstens der Datentyp int verwendet werden darf, ergibt sich als maximale Arraygröße ein Wert von Integer.MAX_VALUE = 2 147 483 647 byte. Das sind knappe 2048 MB. Mit dieser Größenordnung dürften doch die meisten Hauptspeicher im Bürocumputerbereich "etwas" überfordert sein. Mit der Methode freeMemory() aus der Klasse Runtime läßt sich jedoch einfach feststellen, wieviel Hauptspeicher zur Laufzeit zur Verfügung steht.

Mit Hilfe von freeMemory() kann man dann sichere Einlesevorgänge realisieren.

Öffnen einer BinärDatei zum Schreiben


Zum Schreiben von Dateien braucht man die Klasse FileOutputStream. Will man einen gepufferten Zugriff, so verwendet man zusätzlich die Klasse BufferedOutputStream. Beide Klassen sind reale Ableitungen der abstrakten Basisklasse OutputStream, die das Gegenstück zur Klasse InputStream ist (siehe Hierarchie der OutputStreamklassen ).

Die wichtigsten Konstruktoren der Klasse FileOutputStream
FileOutputStream(String fileName)
 
Creates an output file stream to write to the file with the specified name.
FileOutputStream(String fileName, boolean append)
 
Constructs a FileOutputStream object given a file name with a boolean indicating whether or not to append the data written.
FileOutputStream(File file)
 
Creates a file output stream to write to the file represented by the specified File object.
FileOutputStream(File file, boolean append)
 
Constructs a FileOutputStream object given a file object with a boolean indicating whether or not to append the data written.

Die Konstruktoren der Klasse BufferedOutputStream
BufferedOutputStream(OutputStream out)
 
 
 
Create a buffering byte-output stream that uses a default-sized input buffer. Man muß schon den Quellcode lesen, um herauszufinden, wie groß "default-sized" ist. Dort finden man den folgenden Eintrag: private static int defaultBufferSize = 8192;
BufferedOutputStream(OutputStream out, int sz)
 
Create a buffering byte-output stream that uses an input buffer of the specified size.

Schreiben einer BinärDatei


OutputStream stellt drei Methoden zum Schreiben in Dateien bereit.

Schreibmethoden der Klasse OutputStream
ReturntypName der Methode
void
 
write(byte[] buf)
Writes buf.length bytes from the specified byte array to this output stream.
abstract void
 
 
write(byte[] buf, int off, int len)
Writes len bytes from the specified byte array starting at offset off to this output stream.
abstract void
 
 
write(int b)
Writes the specified byte to this output stream.

Die realen write-Methoden stützen sich letzten Endes alle auf die abstrakte write-Methode.

Speichern mit FileOutputStream


FileOutputStream fos = null;

try
{
   fos = new FileOutputStream("data.bin");
   byte[] buf = getData(); // Daten holen
   fos.write(buf);
}
catch(IOException ex)
{
   System.out.println(ex);
}
finally
{
   if(fos!=null)
      try
      {
         fos.close();
      }
      catch(Exception ex)
      {
      }
}

Speichern mit dem BufferedOutputStream


BufferedOutputStream bos = null;

try
{
   BufferedOutputStream bos = new BufferedOutputStream( new FileOutputStream("datei.bin") );
   byte[] buf = getData(); // Daten holen
   bos.write(buf);
}
catch(IOException ex)
{
   System.out.println(ex);
}
finally
{
   if(bos!=null)
      try
      {
         bos.close();
      }
      catch(Exception ex)
      {
      }
}


Übungen


Übungen

top Back Next Up Home