Streamy

 pojem stream

– binárny
– textový

 životný cyklus streamu
 súborové streamy
 výnimky
 bufferované streamy
 stream a klávesnica

Vstupno-výstupné operácie

 ak chceme získavať údaje z, alebo posielať údaje do

miesta iného ako náš program, potrebujeme vytvoriť

komunikačný kanál pre prenos informácií

 kanál označuje sa ako stream

–

možno si ho predstaviť ako trubku (stream), ktorej koniec

máme k dispozícii



z trubky nám môžu údaje vypadávať (po jednom, sekvenčne za

sebou)



alebo ich do nej môžeme vkladať (opäť po jednom)

 prostredníctvom streamov vieme pristupovať k:

–

pamäti

–

súboru

–

používateľskému vstupu/výstupu

–

IP sieti a pod.

Streamy v Jave

knižnica java.io obsahuje komplexnú hierarchiu

(viď tutorial)

základné rozdelenie:

– binárne (abstraktné triedy InputStream,

OutputStream)



pracujú so surovými bajtami (číselné hodnoty
reprezentujúce napr. znaky – ASCII, Unicode)

– textové (abstraktné triedy Reader, Writer)



prekladajú bajty (resp. skupiny bajtov) podľa nastavenia
prostredia: 1 znak = 1 alebo 2 bajty

Základy práce so streamom

životný cyklus:

– vytvorenie
– otvorenie – stream sa často otvára už pri vytvorení,

pokiaľ však otvorený nebol, je nutné túto operáciu
vykonať (alokácia potrebných systémových
prostriedkov)

– vlastná práca – vykonávajú sa potrebné operácie

(volanie metód streamu)

– uzatvorenie – nutné z dôvodov:



nezapísania údajov v cache



zablokované pre ostatné objekty/procesy/používateľov

Ošetrenie chýb

všetky chybové stavy sú riešené výnimkami
základná výnimka IOException
výnimka je povinná

– bez jej použitia program neskompilujete
– je spoločná pre všetky streamy
– každý príkaz streamu v nej musí byť uzavretý

Súborový stream

FileInputStream, FileOutputStream – príklad

Vygenerujte pole náhodných čísel a zapíšte ho do

súboru.

Riešenie - počiatočné

public static void main(String[] args) {
int[] pole= new int[10];
// nacitanie hodnot do pola
for(int i=0;i<pole.length;i++) {
pole[i] = (int) (Math.random()*100);
}

// vytvorenie vystupneho streamu na subor „udaje.dat“
// a sucasne jeho otvorenie/vytvorenie
OutputStream ff = new FileOutputStream("udaje.dat");
for(int i=0;i<pole.length;i++) {
// zapis do streamu ff – zapisuje sa hodnota bajt
ff.write(pole[i]);
}
// uzatvorenie file streamu
ff.close();
}

Riešenie - problém

Zdroj problému

 už spomenutá výnimka

–

udalosť, ktorá vzniká počas behu programu a prerušuje

normálny tok inštrukcií

–

obvykle ide o chybu

 výnimky sa odchytávajú prostredníctvom bloku try –

catch – finally

–

try = skús



ohraničuje blok príkazov, v ktorom môže dôjsť k chybe

–

catch = odchyť (chybu)



ukončuje blok príkazov a zároveň popisuje, čo sa má stať, ak ku chybe

došlo (napr. vypísať info)

–

finally = ukončenie



kód, ktorý sa má vykonať aj v prípade výnimky, aj ak k nej nedôjde

(napr. uvoľnenie pamäte)

Príklad výnimky

int i;
String s;
...
try
{
i=Integer.parseInt(s);
}
catch(NumberFormatException e)
{
System.out.println("Retazec nie je cislo!");
}

Príklad výnimky II.

...
try
{
...
subor.close();
}
catch (IOException e)
{
System.out.println("Chyba:"+e.getMessage());
}

 IOException – vstupno/výstupná výnimka

– detailnú informáciu o nej možno získať z metódy

getMessage

Vráťme sa k súboru

public static void main(String[] args) {

int[] pole= new int[10];

for(int i=0;i<pole.length;i++) {

pole[i] = (int) (Math.random()*100);

System.out.println(pole[i]);

}

try

{

OutputStream ff = new FileOutputStream("udaje.dat");

for(int i=0;i<pole.length;i++) {

ff.write(pole[i]);

}

ff.close();

} catch (IOException e) {

// ak pride k chybem vypise sa ku akej

System.out.println(e.getMessage());

}

}

Údaje v súbore

65
38
44
60
18
47
74
27
14
36

zápis nám uložil údaje, tu sú ich podoby

Načítanie údajov - analógia

// nacitavame aj znak konca suboru, pole musi byt vacsie
int[] pole= new int[20];
int i=0; // ukazovatel na nacitavany prvok v poli

try
{ // InputStream sluzi na citanie
InputStream ff = new FileInputStream("udaje.dat");
do
{
pole[i] = ff.read(); // do pole[i] nacita bajt z ff
i++; // dalsi prvok
// ak sa precita -1 je to info o konci suboru
} while (pole[i]>-1);
ff.close(); // zavretie suboru
} catch (IOException e) { // lapame vynimku
System.out.println(e.getMessage()); // vypis detailu
}

Overenie funkčnosti výnimky

ak si chcete overiť fungovanie odchytávania chýb,

vymažte súbor a spustite program, ktorý sa ho
pokúsi otvoriť

Textový súbor

prepíšte obsah súboru na text a pokúste sa ho v

Jave prečítať a vypísať v textovej podobe.

čítanie a výpis predošlým

spôsobom zrejme veľa
úžitku neprinesie

prečítané údaje (bajt) pretypujeme na char

(pretypovanie poznáme už z minulej prednášky):

– je však potrebné ošetriť prečítanie konca súboru
– pretypovanie hodnoty -1 na char vráti nedefinovanú

hodnotu

Čítanie znakov

char[] pole = new char[20]; // pole je znakove
int cislo,i=0;
try
{ InputStream ff = new FileInputStream("udaje.dat");
do
{
cislo = ff.read(); // precita udaj zo suboru ako bajt
if (cislo>-1) { // ak nie je koniec
pole[i] = (char) cislo; // pretypuje udaj na char
i++;

// zvysi pocet precitanych

prvkov

}
} while (cislo>-1); // a zisti ci bol koniec suboru
ff.close();

// zavrie subor

} catch (IOException e)

{ System.out.println(e.getMessage()); }

Diskusia

čítanie súboru po bytoch však nie je naším cieľom

– v prípade Unicode by sme už museli znak vytvárať z

dvojice bajtov a počas práce by sme určite narazili na

množstvo ďalších obmedzení

práca s bajtami je navyše veľmi neefektívna:

– každé prečítanie a každý zápis sa vykonáva priamo na

zdroji (na fyzickom zariadení) => zaťažovanie

súborového systému, zdržiavanie, opotrebúvanie

hardvéru atď.

 pre prácu s textom, ktorá tvorí veľkú väčšinu práce je

žiaduce používať „bezpečnejšie“ typy:

– Reader, Writer

Bufferované streamy

streamy, ktoré okrem základných operácií

obsahujú buffer (vyrovnávaciu pamäť) a sadu

ďalších operácií, prostredníctvom ktorých

optimalizujú prístup k údajom

bufferovaný stream vytvárame obvykle tak, že

mu ako vstupný parameter konštruktora zadáme

podriadený stream, napr.:
BufferedReader br =

new BufferedReader(new

FileReader("subor.txt"));

umožňuje čítanie riadkov:

s = br.readLine()

najvrchnejší „stream“ pri svojom zavretí uzavrie

aj všetky „nižšie postavené“

Textový súbor

Napíšte program schopný prečítať zadaný textový

súbor po riadkoch a vypísať ich.

Riešenie

String riadok;
try
{
// vytvorim filereader na čítanie z textového suboru
FileReader ff = new FileReader("udaje.txt");
// „zabalim ho“ do bufferovanej triedy
BufferedReader subor = new BufferedReader (ff);
do {
riadok = subor.readLine(); // precitam riadok
// ak nebol koniec suboru (hodnota null) vypisem
if (riadok != null ) System.out.println(riadok);
} while (riadok != null); // kym nie je koniec sub.
subor.close(); // zavriem najvrchnejsi stream
}
catch (IOException e) {
System.out.println(e.getMessage());
}

Textový súbor

Napíšte program, ktorý vygeneruje zadaný počet

náhodných celých čísel a uloží ich do textového

súboru.

pri riešení použite InputDialog, v našom riešení

nastavíme hodnotu v kóde

Textový súbor

Zabezpečte, aby každé číslo bolo uložené v

osobitnom riadku.

Riešenie

int cislo, pocet=10;
String txt;

try
{// pre zapis zase File- a Buffered-Writer
FileWriter ff = new FileWriter("cisla.txt");
BufferedWriter subor = new BufferedWriter (ff);
for(int i=0;i<pocet;i++) {
cislo = (int) (-500+Math.random()*1001); // nah. cislo

txt = Integer.toString(cislo); // prevod na string

subor.write(txt);// zapis textu do suboru
subor.newLine(); // odriadkovanie, resp. doplnenie „/n“
}
subor.close(); // zatvorenie suboru
}
catch (IOException e) {
System.out.println(e.getMessage()); }

Štandardný vstup (klávesnica)

údaje prichádzajú do programu cez buffer
na začiatku bolo preto pre nás jednoduchšie volať

InputDialog, ktorý vracal string

niekedy je však nevyhnutné použiť aj konzolový

vstup

Štandardný vstup (kód)

cez InputStreamReader „tečú“ znaky z System.in a

následne sa preklápajú do BufferredReadera,

odkiaľ už vieme prečítať celý riadok

try {

// vytvorim kb ako stream zo vstupu

InputStreamReader kb = new InputStreamReader (System.in);

// „obalim“ ho buferom

BufferedReader bufer = new BufferedReader (kb);
// ten disponuje metodou na precitanie riadku

// ukoncenie riadku na vstupe oznamim Enterom

String vstup = bufer.readLine();

// koniec prace s buferom

bufer.close();
}catch (IOException e) {

System.out.println(e.getMessage());

}

Štandardný vstup po znakoch

analógia, čítam vstup kým nestlačím Enter
následne sa začne spracúvať buffer

– vstupy prekladám z bajtov na char
– prípadne vkladám do stringu moje vstupy

dôležitou je podmienka ukončenia

– napr. Enter? (ukončovací znak \n)
– iný znak (0, x a pod.)

Štandardný vstup po znakoch

String vstup="";

char znak;

int i=0;

try {

InputStreamReader kb = new InputStreamReader(System.in);

BufferedReader bufer = new BufferedReader (kb);

do {

i = bufer.read(); // udaj vstupi ako cislo bajt

znak = (char) i; // pretypuje sa na znak

// prida sa k vstupnemu retazcu

vstup = vstup + String.valueOf(znak);

System.out.println("data:"+vstup); // kontrolny vypis

} while (znak != '\n'); // ukoncovacia podmienka-ENTER

bufer.close();

// uzatvorenie buffera

}

catch (IOException e) {

System.out.println(e.getMessage());}

Príklady na riešenie



Napíšte program, ktorý pre číselné údaje uložené v súbore „data.txt“ ako text –
každé číslo na samostatnom riadku, nájde maximum.



V textovom súbore, ktorého názov zadajte prostredníctvom InputDialogu nájdite:



najdlhší a najkratší riadok (vypíšte ich poradové číslo a obsahujúci text),



najdlhšie a najkratšie slovo (vypíšte slová),



* všetky slová, ktoré neobsahujú samohlásky.



Zistite, koľko sa v zadanom súbore nachádza:



riadkov,



slov,



viet.



Skopírujte údaje zo súboru data.txt do súboru data1.txt tak, že veľké písmená
zameníte za malé a malé za veľké.



Pre zadaný súbor zistite počty jednotlivých písmen (‘a’-’z’, ‘A’-’Z’). V záverečnom
výstupe vypíšte len tie písmená, ktoré sa v súbore nachádzajú aspoň raz.



Pre zadaný súbor vytvorte súbor „zrkadlo.txt“, v ktorý bude obsahovať:



zrkadlové riadky pôvodného súboru



*v každom riadku budú zrkadlové obrazy slov (napr. mama ma emu – amam am ume)