Advanced   Java   Services

Lesen und Schreiben von Textdateien

Wir verwenden die Klasse FileReader. Will man einen gepufferten Zugriff, so verwendet man stattdessen die Klasse BufferedReader, die ihrerseits auf die Klasse Reader aufsetzt. FileReader und BufferedReader sind reale Ableitungen der abstrakten Basisklasse Reader (siehe Hierarchie der Readerklassen ).

Wir verwenden die Klasse FileReader. Will man einen gepufferten Zugriff, so verwendet man stattdessen die Klasse BufferedReader, die ihrerseits auf die Klasse Reader aufsetzt. FileReader und BufferedReader sind reale Ableitungen der abstrakten Basisklasse Reader (siehe Hierarchie der Readerklassen ).

Reader stellt drei Lesemethoden zum Einlesen von Textdaten aus Dateien bereit.

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

Quellcode der ersten read-Methode:

public int read() throws IOException
{
   char cb[] = new char[1];
   if (read(cb, 0, 1) == -1)
      return -1;
   else
      return cb[0];
}

Quellcode der zweiten read-Methode:

public int read(char cbuf[]) throws IOException
{
   return read(cbuf, 0, cbuf.length);
}

Damit ist auch klar, wie die zweite Methode arbeitet, sie liest höchstens so viele Zeichen ein, wie in dem Array Platz haben. Die folgenden Beispiele demonstrieren die drei Methoden.

FileReader fr = null;

try
{
   String fileName="TextDateiLesen.java";
   fr = new FileReader(fileName);
   StringBuffer sb = new StringBuffer();
   int ch;
   while( (ch=fr.read()) != -1 )
      sb.append((char)ch);

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

FileReader fr = null;

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

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

FileReader fr = null;

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

   fr = new FileReader(file);
   fr.read(buf, 0, len) ;
   text = new String(buf);
   System.out.println(text);
}
/*catch(FileNotFoundException ex)
{
   System.out.println(ex);
}*/
catch(IOException ex)
{
   System.out.println(ex);
}
finally
{
   try
   {
     if(fr!=null) fr.close();
   }
   catch(Exception ex)
   {
   }
}

Die Klasse BufferedReader stellt eine weitere Einlesemethode zur Verfügung, die ein zeilenweises Einlesen einer Textdatei ermöglicht.

FileReader fr = null;
BufferedReader br = null;

try
{
   String fileName="TextDateiLesen3.java";
   File file = new File(fileName) ;
   fr = new FileReader(file);
   br = new BufferedReader(fr) ;

   String line ;
   StringBuffer sb = new StringBuffer();
   // systemeigenes Zeilenumbruchszeichen ermitteln
   String sep = System.getProperty("line.separator");

   while( (line=br.readLine()) != null )
      sb.append(line+sep) ;

   System.out.println(sb);  //ganze Datei ausgegeben
}
/*catch(FileNotFoundException ex)
{
   System.out.println(ex);
}*/
catch(IOException ex)
{
   System.out.println(ex);
}
finally
{
   try
   {
     if(br!=null) br.close();
     if(fr!=null) fr.close();
   }
   catch(Exception ex)
   {
   }
}

readLine() verhält sich neutral und liest keinen Zeilenumbruch mit ein. So kann man selbst bestimmen, welches Zeilenumbruchszeichen man verwendet. Im obigen Fall wird das systemeigene Zeilenumbruchszeichen verwendet, welches man sich über die SystemProperties besorgt.

Seit der Zeit der Telegraphie, in der der ASCII-Code eingeführt wurde, werden die Zeichen

CR = carriage return = ASCII-Code 13 = '\r'

und

LF = line feed = ASCII-Code 10 = '\n'

zur Zeilentrennung verwendet. Als der ASCII-Code zur Speicherung von Texten in Dateien übernommen wurde, konnte man sich nicht auf ein einheitliches Zeilenumbruchszeichen verständigen. So gibt es nun drei verschiedene Zeilenumbruchszeichen:

Max-Systeme verwenden CR = carriage return = ASCII-Code 13 = '\r'

Unix-Systeme verwenden LF = line feed = ASCII-Code 10 = '\n'

Windows-Systeme verwenden CR+LF = carriage return+line feed = "\r\n"

Beim Einlesen mit den read()-Methoden werden sämtliche Zeichen gelesen, also auch die Zeilenumbruchszeichen. Nicht alle Varianten können können von den graphischen Komponenten in Java umgesetzt werden.

Die Klasse System liefert das (systemabhängige) Zeilenumbruchszeichen über die Properties der Klasse System.

String separator = System.getProperty("line.separator") ;

Die Klasse Character besitzt eine Konstante

Character.LINE_SEPARATOR

Diese Konstante steht für CR, also für das Zeilenumbruchszeichen auf Mac.

Mit einem StringReader kann man Strings so behandeln wie Dateien. Steckt man ihn in einen BufferedReader, so steht die readLine()-Methode zur Verfügung und man kann den String zeilenumbruchsneutral einlesen. Das folgende Beispiel liest einen String mit unterschiedlichen Zeilenumbruchszeichen und gibt einen neuen String mit Unix-Zeilenumbruchszeichen zurück:

public String insertUnixLineWrappings(String text)
{
   BufferedReader br = null;

   try
   {
      //"Datei öffnen"
      br = new BufferedReader( new StringReader(text) );
      StringBuffer sb = new StringBuffer();

      String line; // "Datei" lesen
      while (  (line=br.readLine() )!=null )
         sb.append(line + '\n');

      return sb.toString();
   }
   catch(IOException ex)
   {
      return null;
   }
   finally
   {
      try
      {
         if(br!=null) br.close();
      }
      catch(Exception ex)
      {
      }
   }
}

Natürlich kann man die Methode noch flexibler gestalten, indem man als zweiten Parameter das einzufügende Zeilenumbruchszeichen eingibt:

public String insertLineWrappings(String text, String style)
{
   if ( style.equals("\r") || style.equals("\n") || style.equals("\r\n")
   {
      BufferedReader br = null;

      try
      {
         //"Datei öffnen"
         BufferedReader br = new BufferedReader( new StringReader(text) );
         StringBuffer sb = new StringBuffer();

         String line; // "Datei" lesen
         while (  (line=br.readLine() )!=null )
            sb.append(line + style);

         // Datei schließen
         br.close();
         return sb.toString();
      }
      catch(IOException ex)
      {
         return null;
      }
      finally
      {
         try
         {
            if(br!=null) br.close();
         }
         catch(Exception ex)
         {
         }
      }
   }
   else
      throw new IllegalArgumentException("second paramater contains no wrap style");
}

Die beiden letzten Beispiele werfen die Frage auf, in welcher Reihenfolge try, catch und finally abgearbeitet werden, wenn in den Blöcken return auftritt. Die Antwort: Der finally-Block wird in jedem Fall ausgeführt und er wird zudem vor return abgearbeitet!

Zum Schreiben von Dateien braucht man die Klasse FileWriter. Will man einen gepufferten Zugriff, so verwendet man zusätzlich die Klasse BufferedWriter. Beide Klassen sind reale Ableitungen der abstrakten Basisklasse Writer, die das Gegenstück zur Klasse Reader ist (siehe Hierarchie der Writerklassen ).

Writer stellt gleich fünf Methoden zum Schreiben von Textdaten in Dateien bereit.

Die realen write-Methoden stützen sich letzten Endes alle auf die abstrakte write-Methode. Hier nur der Quellcode von zwei der vier Methoden.

public void write(char cbuf[]) throws IOException
{
   write(cbuf, 0, cbuf.length);  // abstrakt
}

public void write(String str) throws IOException
{
   write(str, 0, str.length());
   // diese Methode verwendet dann die abstrakte write-Methode.
}

FileWriter fw = null;

try
{
   fw = new FileWriter("datei.name");
   fw.write(text);  // text ist ein String
}
catch(IOException ex)
{
   System.out.println(ex);
}
finally
{
   if (fw != null)
      try
      {
        fw.close();
      }
      catch(Exception ex)
      {
      }
}

Zum Schreiben eines betriebssystemabhängigen Zeilenumbruchs bietet BufferedWriter die Methode newLine() an.

BufferedWriter bw = null;

try
{
   bw = new BufferedWriter( new FileWriter("datei.name") );
   bw.write(text);  // text ist ein String
   // bw.newLine() ;    // evtl. Zeilenumbruchszeichen einfügen
}
catch(IOException ex)
{
   System.out.println(ex);
}
finally
{
   if (bw != null)
      try
      {
        bw.close();
      }
      catch(Exception ex)
      {
      }
}