Töö failidega

Põhimõisteid

Voog (ingl.k. stream)

Voogu iseloomustab:
• vool on ühel pool tootja (allikas) ning teisel pool tarbija,
• juurdepääs voo andmetele on järjestikune (nn. jadapöördus).


Java seisukohalt võib vood jagada:

• sisendvoog ja väljundvoog (ingl.k. input stream, output stream) - vastavalt rollile "tootja-tarbija" suhtes;
• baidivoog ja tekstivoog - vastavalt andmete tüübile, kahendandmed või tekst, baidivoogu saab edasi interpreteerida (andmevoog);
• puhverdatud ja puhverdamata voog - efektiivsuse kaalutlustel võib tegelikud S/V operatsioonid puhverdada;
• vastavalt voo kandjale: failivoog (ingl.k. file stream), massiivivoog (array stream), toruvoog (piped stream), ...

Fail (ingl.k. file)

Faile ja katalooge käsitletakse Javas koos (analoog Unix-tüüpi failisüsteemidega).

Faili saab kasutada kui voogu (failivoog) või kui otsepöördusfaili (e. suvapöördusfaili, ingl.k. random access file).

Programmides saab avatud faili kohta informatsiooni edastamiseks kasutada nn. failikirjeldajat (ingl.k. file descriptor), mis viitab failile kohalikus failisüsteemis või pistikule (ingl.k. socket).

Toru e. konveier (ingl.k. pipe)

Toru on kasutusel andmete suunamiseks ühe protsessi väljundist teise protsessi sisendisse. Toru koosneb kahest otsast - toru sisendvoost ja toru väljundvoost, mida reeglina kasutavad erinevad lõimed.

Java vahendid tööks voogude, failide ja torudega

Klassid paketis java.io (mittetäielik loend)

IOException    ( <- Exception <- Throwable )
EOFException
FileNotFoundException
InterruptedIOException
......
 
File

FileDescriptor

InputStream

ByteArrayInputStream
FileInputStream
FilterInputStream

BufferedInputStream
DataInputStream

PipedInputStream
StringBufferInputStream

OutputStream

ByteArrayOutputStream
FileOutputStream
FilterOutputStream

BufferedOutputStream
DataOutputStream
PrintStream

PipedOutputStream

RandomAccessFile

Reader

BufferedReader
CharArrayReader
FilterReader
InputStreamReader

FileReader

PipedReader
StringReader

StreamTokenizer

Writer

BufferedWriter
CharArrayWriter
FilterWriter
OutputStreamWriter

FileWriter

PipedWriter
PrintWriter
StringWriter

Juhiseid orienteerumiseks

Standardsisend System.in kuulub klassi InputStream

Standardväljund System.out ja veaväljund System.err kuuluvad klassi PrintStream

Tekstivoogudega (NB! Unicode) tegelevad Reader- ja Writer-klassid, baidivoogudega InputStream- ja OutputStream-klassid, andmevoogudega DataInputStream- ja DataOutputStream-klassid, kusjuures andmevoo interpreteerimiseks võib ise luua uusi mooduseid spetsialiseerides klasse prefiksiga Filter...

Kui voo allikaks on fail, siis kasutatakse "aluspõhjaks" (täpsem info leidub vookonstruktorite kirjeldustes) klasse FileInputStream ja FileOutputStream (andmed) või FileReader ja FileWriter (tekst).

Sisemälu saab kasutada baidivoona (ByteArrayOutputStream, ByteArrayInputStream) või tekstivoona (CharArrayWriter, StringWriter, CharArrayReader, StringReader, StringBufferInputStream).

Torude tegemiseks on PipedInputStream ja PipedOutputStream (andmed) või PipedReader ja PipedWriter (tekst).

Puhverdatud voogude klassinime prefiks on Buffered...

Print... klassid ei anna erindeid ning sisaldavad muid mugavusi (näit. print- ja println-meetodid paljude tüüpide jaoks).

Andmevoo töötlemine

Reeglina tuleb S/V-operatsioonide kasutamisel tegelda ka erinditega, v.a. Print...klassid ja töö otsepöördusfailidega. Seega
 
try { S/V operatsioonid jm.
} ...
catch (IOException e) { ... }
 
Tekstivoo lõputunnuseks on String null:
 
while ((rida = sisendvoog.readLine()) != null) ...
 
Baidivoo korral annab baidi lugemine täisarvu (int) vahemikus 0 kuni 255, lõputunnuseks on negatiivne täisarv -1:
 
while ((n = sisendvoog.read()) != -1) ...
 
Suvalise andmevoo korral tekitab katse lugeda faili lõpust kaugemale erindi EOFException.

Lihttüüpide lugemiseks/kirjutamiseks tuleb kasutada klasse DataInputStream ja DataOutputStream või RandomAccessFile (tegelikult sobivad DataInput ja DataOutput liidesed, mida nimetatud klassid realiseerivad).

Puhverdatud voogude korral saab puhvri "jõuga" välja kirjutada kasutades flush()-meetodit.

Reeglina on voogudel kaks taset, mille määravad voo kasutuseesmärk (ülemine tase) ning kandja ("aluspõhi").

Voo "aluspõhi" määratakse üldiselt voo loomisel, näit.

 
PrintWriter tekstivoog =
new PrintWriter
   (new FileWriter ("tekst.txt"), true);
 
(saan kasutada print-meetodeid, et juurde kirjutada faili),
 

BufferedReader sisendvoog =

new BufferedReader
    (new InputStreamReader (System.in));
 
(standardsisend on puhverdatud).

Failid

Ettevaatlik tuleb olla teede määramisel (File.separatorChar) ja nimede etteandmisel (suur- ja väiketähed). Faile ja katalooge käsitletakse sarnaselt.

Meetodeid: exists, canRead, canWrite, isFile, isDirectory, isAbsolute, getName, getPath, getAbsolutePath, getParent, lastModified, length, mkdir, mkdirs, list, renameTo, delete

Otsepöördusfailid

Loomisel määratakse kasutusviis ("r" / "rw"):
 
new RandomAccessFile (fail, kasutusviis)
 
Failiosuti algväärtus on 0.
Olulised meetodid on read..., write..., seek, skipBytes, getFilePointer, length.

Torud

Toru abil saavad kaks (või enam) protsessi (Java programmi lõime) toota ja tarbida andmeid ilma ilmutatud kujul sünkroniseerimisdirektiive kasutamata. Programmid ei pea teadma, kas andmed tulevad failist, sisemälust või teisest lõimest.

Toru "tootjapoolne ots" kuulub ühte klassidest PipedOutputStream (andmed) või PipedWriter (tekst), "tarbijapoolne ots" on vastavalt PipedInputStream või PipedReader. Otsad on iseseisvad objektid ja neid saab ühendada dünaamiliselt (connect) (muidugi saab seda teha ka "teise otsa" loomisel, kui "esimene" on juba olemas). Reeglina alustab ja lõpetab tootja omad operatsioonid toruga enne tarbijat, kuid lõplikult suletakse toru tarbija poolt.

Mõned näited

Järgnevates näidetes mitte unustada

import java.io.*;

Tekstirea lugemine standardsisendist

Standardsisend on muutujas System.in , vaikimisi vastab sellele klaviatuur.

      try {
         BufferedReader sisse = new BufferedReader
                      (new InputStreamReader (System.in));
         System.out.print ("Anna tekst: ");
         String s = sisse.readLine(); // rida teksti ka"es
         System.out.println ("Tippisid: " + s);
      }
      catch (IOException e) {
         System.out.println ("S/V viga: " + e);
      }

Teksti kirjutamine faili

      try {
         PrintWriter valjund = new PrintWriter 
                   (new FileWriter ("tekst.txt"), true);
         valjund.println ("Esimene rida");
         valjund.println ("Teine rida ja\nkolmas rida");
         valjund.close();
      }
      catch (IOException e) {
         System.out.println ("S/V viga: " + e);
      }

Teksti lugemine failist

      try {
         BufferedReader sisend = new BufferedReader 
                      (new FileReader ("tekst.txt"));
         String rida;
         while ((rida = sisend.readLine()) != null) {
            // rida olemas, vo~ime to"o"delda
            System.out.println (rida);
         }
         sisend.close();
      }
      catch (IOException e) {
         System.out.println ("S/V viga: " + e);
      }

Andmete kirjutamine faili

      try {
         DataOutputStream valjundvoog =
            new DataOutputStream 
                  (new FileOutputStream ("andmed.bin"));
         valjundvoog.writeInt (1234);
         valjundvoog.writeDouble (1.23e4);
         valjundvoog.close();
      }
      catch (IOException e) {
         System.out.println ("S/V viga: " + e);
      }

Andmete lugemine failist (struktuur teada)

      try {
         DataInputStream sisendvoog = new DataInputStream 
                      (new FileInputStream ("andmed.bin"));
         int n = sisendvoog.readInt();
         double d = sisendvoog.readDouble();
         sisendvoog.close();
         System.out.println ("Loeti: " + n + " ja " + d);
      }
      catch (EOFException e) { // oluline to"o"delda
         System.out.println ("Faili lopp tuli ette: " + e);
      }
      catch (IOException e) {
         System.out.println ("S/V viga: " + e);
      }

Andmete lugemine failist baithaaval

      try {
         FileInputStream voog = new FileInputStream 
                                           ("andmed.bin");
         System.out.println ("Baidid on: ");
         int bait;
         while ((bait = voog.read()) != -1) {
            System.out.print (Integer.toHexString (bait) +
                                                     " ");
         }
         voog.close();
         System.out.println();
      }
      catch (IOException e) {
         System.out.println ("S/V viga: " + e);
      }

Faili lugemine baitmassiivi

      try { 
         FileInputStream p = new FileInputStream
                                    ("tekst.txt"); 
         byte[] sisu = new byte [p.available()]; 
         p.read (sisu); 
         p.close(); 
         // siin on meil kogu fail baitmassiivina
         System.out.write (sisu);
      } 
      catch (IOException e) { 
         System.out.println ("S/V viga: " + e);
      }

Kataloogi sisu lugemine

      File f = new File ("tmp"); // suval. kat. nimi
      if (!f.exists() || !f.canRead()) {
         System.out.println ("Ei saa lugeda: " + f);
         return;
      }
      if (f.isDirectory()) {
         String [] nimekiri = f.list(); // String-massiiv
         for (int i=0; i < nimekiri.length; i++)
            System.out.println (nimekiri [i]);
      } else {
         System.out.println ("Ei ole kataloog: " + f);
      }

Filter baidivoo tõlgendamiseks ja mälupuhver voo kandjana

      //==============================================================
      // rot13 filtri katsetamine ja ma"lupuhver faili rollis
      //==============================================================

      byte [] bfail = null;  // bfail on baitmassiiv

      System.out.println ("Kodeeritud faili kirjutamine.");
      try {
         // malu on va"ljundvoog, mille hiljem teeme massiiviks
         ByteArrayOutputStream malu = new ByteArrayOutputStream();

         // r13 on kodeeritud voog, mille kandjaks on malu
         Rot13OutputStream r13 =
            new Rot13OutputStream (malu);
         r13.write ('A');
         r13.write ('B');
         r13.write ('C');
         r13.write ('2');
         r13.write ('n');
         r13.write ('o');
         r13.write ('p');
         r13.write ('.');
         r13.close();

         bfail = malu.toByteArray(); // teise programmi jaoks meelde
      }
      catch (IOException e) {
         System.out.println ("S/V viga: " + e);
      }

   System.out.println ("Kodeeritud fail:\n" + new String (bfail));

   System.out.println ("Faili lugemine ja dekodeerimine.");
   try {
      Rot13InputStream r13 =
         new Rot13InputStream (new ByteArrayInputStream (bfail));
      int b;
      System.out.println ("Dekodeeritud fail: ");
      while ((b = r13.read()) != -1) {
         System.out.print ((char)b);
      }
      System.out.println();
   }
   catch (IOException e) {
         System.out.println ("S/V viga: " + e);
   }

   .....

//=======================================================================
// Filtrid
//=======================================================================

class Rot13InputStream extends FilterInputStream {

   Rot13InputStream (InputStream i) {
      super (i);
   }

   public int read() throws IOException {
      return rot13 (in.read()); // in on isendimuutuja
   }

   static int rot13 (int c) { // sama kasutame ka po"o"rdteisenduseks
      if ((c >= 'A') && (c <= 'Z'))
         c = 'A' + (((c - 'A') + 13) % 26);
      if ((c >= 'a') && (c <= 'z'))
         c = 'a' + (((c - 'a') + 13) % 26);
      return c;
   }

} // Rot13InputStream lopp

//====================================================================

class Rot13OutputStream extends FilterOutputStream {

   Rot13OutputStream (OutputStream o) {
      super (o);
   }

   public void write (int c) throws IOException {
      out.write (Rot13InputStream.rot13 (c)); // out on isendimuutuja
   }

} // Rot13OutputStream lopp


Tootja-tarbija sünkroniseerimine toru abil

/**
 * Fail Torud.java
 * @author Jaanus Poial
 * @version 0.1 kevad 99
 */

//======================================================================
// Torude tegemine (ingl.k. pipe) 
//======================================================================

import java.io.*;

public class Torud {

   public static void main (String[] parameetrid) {

      try {
         PipedOutputStream kirjutaja = new PipedOutputStream();
         PipedInputStream lugeja = new PipedInputStream();
         Tootja kirjutajaloim = new Tootja (kirjutaja);
         Tarbija lugejaloim = new Tarbija (lugeja);
         kirjutaja.connect (lugeja); // saab teisiti, aga su"mmetria
         kirjutajaloim.start();
         lugejaloim.start();
      }
      catch (IOException e) {
         System.out.println ("S/V viga: " + e);
      }

   } // main lopp

} // Torud lopp

//======================================================================

class Tootja extends Thread {

   PipedOutputStream voog;

   Tootja (PipedOutputStream p) {
      voog = p;
   }

   public void run() {
      System.out.println ("Tootja alustas... ");
      try {
         for (int i = 0; i < 9; i++) {
            int r = (int)(Math.random()*256);
            voog.write (r); // toode toodetud
            System.out.println (i + ". toodetud: " + r);
            try {
               sleep ((int)(Math.random()*1000));
            } catch (InterruptedException e) {}
         }
         voog.close(); // lugeja saab edasi lugeda
      }
      catch (IOException e) {
         System.out.println ("S/V viga: " + e);
      }
      System.out.println ("Tootja lopetas");
   }

} // Tootja lopp

//=================================================================

class Tarbija extends Thread {

   PipedInputStream voog;

   Tarbija (PipedInputStream p) {
      voog = p;
   }

   public void run() {
      System.out.println ("Tarbija alustas... ");
      try {
         int i = 0;
         int r = -1;
         while ((r = voog.read()) != -1) {
            System.out.println (i++ + ". tarbitud: " + r);
            try {
               sleep ((int)(Math.random()*1000));
            } catch (InterruptedException e) {}
         }
         voog.close(); // lugeja paneb lo~plikult kinni
      }
      catch (IOException e) {
         System.out.println ("S/V viga: " + e);
      }
      System.out.println ("Tarbija lopetas");
   }

} // Tarbija lopp