Datový proud

Všechny vstupní třídy jsou potomky třídy InputStream a výstupní třídy potomky OutputStream. Nejzákladnějším typem proudu je bajtový proud. Tento proud čte nebo zapisuje data na nízké úrovni po 8bitových svazcích. Doporučuje se tento typ proudu nepoužívat, protože existují specializovanější alternativy (viz dále).

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

[[public]] [[Třída (programování)|class]] ZkopírujBajty {
    public static [[void]] main(String[] args) throws [[Výjimka (programování)|IOException]] {

        FileInputStream in = null;
        FileOutputStream out = null;

        try {
            in = new FileInputStream("vstup.txt"); //otevři vstupní proud
            out = new FileOutputStream("vystup.txt"); //otevři výstup.proud
            int c; //právě čtený bajt; pokud je -1, je konec souboru

            while ((c = in.read()) != -1) { //dokud jsou data na vstupu
                out.write(c); //pošli je na výstup
            }
        } finally {
            if (in != null) { //pokud je otevřený vstupní proud
                in.close(); //uzavři ho
            }
            if (out != null) { //pokud je otevřený výstupní proud
                out.close(); //uzavři ho
            }
        }
    }
}

V tomto případě je čten obsah souboru vstup.txt bajt po bajtu a ukládán do souboru vystup.txt. Oba proudy je třeba po použití uzavřít, protože těchto proudů může operační systém poskytnout omezené množství.

Java používá pro vnitřní reprezentaci znaků kódování Unicode. Znakové proudy s tím počítají a dokážou toto kódování při zápisu a čtení překládat na jiná. Všechny vstupní třídy jsou potomky třídy Reader a všechny výstupní třídy jsou potomky třídy Writer.

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class ZkopírujZnaky {
    public static void main(String[] args) throws IOException {

        FileReader in = null;
        FileWriter out = null;

        try {
            in = new FileReader("vstup.txt"); //otevři vstupní proud
            out = new FileWriter("výstup.txt"); //otevři výstupní proud

            int c; //právě čtený znak (16 bitů), -1 znamená konec souboru
            while ((c = in.read()) != -1) { //dokud jsou data na vstupu
                out.write(c); //zapiš znak na výstup
            }
        } finally {
            if (in != null) { //pokud je otevřený vstupní proud
                in.close(); //uzavři ho
            }
            if (out != null) { //pokud je otevřený výstupní proud
                out.close(); //uzavři ho
            }
        }
    }
}

Běžně je každý požadavek na zápis nebo čtení zpracováván přímo operačním systémem. To může vést k neefektivitě programu, protože každý takový požadavek může potřebovat např. přistupovat k disku nebo síťovým zdrojům, což jsou časově relativně náročné operace. Vyrovnávací paměť (buffer) je místo v operační paměti vyhrazené pro dočasné uchování dat před jejich přesunem na jiné místo. Pouze pokud je vyrovnávací paměť prázdná, použije se běžný přístup. Proudy lze „naučit“ používat vyrovnávací paměť využitím návrhového vzoru dekorátor. Proud, který čte ze souboru a využívá vyrovnávací paměť je možno vytvořit následovně:

inputStream = new BufferedReader(new FileReader("vstup.txt"));

Nejprve se vytvoří proud pro čtení ze souboru (FileReader) a ten poté „obalí“ proud pracující s vyrovnávací pamětí (BufferedReader). Obdobně pracuje i výstupní proud:

outputStream = new BufferedWriter(new FileWriter("characteroutput.txt"));

V Javě existují celkem 4 třídy, které obalují proudy: BufferedInputStream, BufferedOutputStream, BufferedReader, BufferedWriter.[3]

Je dobrým zvykem vyprazdňovat vyrovnávací paměť (zapsat změněná data) na kritických místech. Tato operace uloží celý obsah vyrovnávací paměti na cíl proudu (soubor, zařízení atd.) Běžně se používá anglický výraz „flush“.

Dekorátor je návrhový vzor, který se používá k obohacení existujících objektů o přidanou funkcionalitu. Funkce, které neupravuje, deleguje na obalený objekt. V angličtině se člověk může setkat s označením „wrapper“. Uplatnění tento vzor najde třeba při tvorbě GUI, kdy lze například podkladovou třídu

Okno o = new Okno();

obohatit o titulek tak, že

o = new OknoSTitulkem(o);

a dále třeba o posuvník

o = new OknoSPosuvníkem(o);

Java obsahuje třídy pro pohodlné čtení a zápis primitivních datových typů a typu String. Nejrozšířenější třídy jsou DataInputStream a DataOutputStream. String je ukládán v kódování UTF-8. Údaje takto uložené např. do souboru nejsou uživatelsky přívětivé a s výjimkou řetězců čitelné. Metody pro čtení jsou readDouble, readInt, readUTF. Obdobně metody pro zápis mají předponu write.

Většina standardních tříd implementuje rozhraní Serializable (serializovatelný), které je nezbytné pro jejich podporu objektovými proudy. Objektové proudy rozšiřují datové proudy, takže objektové proudy umí pracovat i s primitivními datovými typy. Nové metody jsou readObject a writeObject. Pokud metoda readObject vrátí jiný než očekávaný objekt, vyhodí výjimku typu ClassNotFoundException.

Pokud se objekt neskládá jen z primitivních typů ale i z referencí na další objekty, je potřeba zachovat tyto reference. Proto je při zápisu objektu uložit i všechny objekty, na které má daný objekt odkaz. Podobně se bude chovat čtecí proud, který se bude snažit zrekonstruovat celou takovou síť objektů.[4]

• Pecinovský, Rudolf. Návrhové vzory. Brno : COMPUTER PRESS, 2007. 978-80-251-1582-4.