JAVA – kontenery: interfejsy Collection i Map import java.util.*; public class Prog57 { public static void main(String [] arg) { Collection c = new ArrayList(); // ArrayList jest rodzaju List c.add("one"); c.add(new Integer(3)); System.out.println(c); // [one, 3, one] Collections.fill((List)c,"one"); // działa tylko dla List i pokrewnych, zastępuje istniejące elem. System.out.println(c); // [one, one, one] Collection c2 = new HashSet(); // HashSet jest rodzaju Set , będzie można dodawać tylko po jednym // elemencie każdego rodzaju c2.add("one"); c2.add("two"); c2.add(new Integer(3)); System.out.println(c2); // [two, one, 3] // odwzorowanie klucz--wartość Map m = new HashMap(); m.put("one","1"); m.put("two","2"); m.put(new Double(3.12),"3.12"); System.out.println(m); // {two=2, one=1, 3.12=3.12 } // klucz z lewej, wartość z prawej } } //Prog57 JAVA 2 w praktyce

JAVA – kontenery a typy przechowywanych obiektów import java.util.*; class MyType { float f = 3.3f; } public class Prog58 { public static void main(String [] arg) { ArrayList c = new ArrayList(); c.add("one"); c.add("two"); c.add(new Integer(3)); System.out.println(" rozmiar = " + c.size()); // 4 System.out.println(c); // [one, two, 3 ] String s = (String)c.get(1); // wyjmowanie elementu o nr System.out.println(s); // two // s = (String)c.get(2); // wyjątek , niezgodne typy c.add(new MyType()); // s = (String)c.get(4); // wyjątek , niezgodne typy }} //Prog58 ArrayList można traktować jak tablicę o rozszerzalnej pojemności JAVA 2 w praktyce

JAVA – inteligentny kontener dla klasy obiektów import java.util.*; class MyType { float f = 3.3f; MyType(float t) { f = t; } public float show(int nr) { return f; } } class MyTypeList { private ArrayList a = new ArrayList(); public void add(MyType t) { a.add(t); } public MyType get(int nr) { return (MyType)a.get(nr); } public int size() { return a.size(); } public float show(int nr) { return ((MyType)a.get(nr)).f; } public class Prog59 { public static void main(String [] arg) { MyTypeList m = new MyTypeList(); m.add(new MyType(2.1f)); m.add(new MyType(3.1f)); System.out.println(" rozmiar = " + m.size()); // 2 System.out.println(m.show(0)); // 2.1 MyType t = new MyType(0.2f); t = m.get(0); System.out.println(t.show(0)); // 2.1 } } //Prog59 JAVA 2 w praktyce

JAVA –implementacja metod interfejsu Collection System.out.println(a); // tak jak w l Object [] ob = l.toArray(); // zwraca Object [] z elem. kontenera System.out.println(ob.length); //--> 5 String [] s = (String [])l.toArray(new String [1]); // zwrot tab [] a.clear(); // usuwa wszystko z a System.out.println(a.isEmpty()); // czy jest pusta? true l.remove("lin1"); // usuń argument "lin1" System.out.println(l); // [lin2, lin3, lin1, lin1] a.add("lin1"); l.removeAll(a); // usuń wszystkie argumenty z l które są w a a.add("lin3"); l.retainAll(a); // część wspólna zbiorów pozostanie w l System.out.println(l.size() + " " + l); // -> 1 [lin3] System.out.println(l.contains("lin3")); // czy zawiera element -> true System.out.println(l.contains(a)); // czy zbiór a jest podzbiorem l? – //-> false } } //Prog60 import java.util.*; public class Prog60 { public static void prt(Collection c) { Iterator i = c.iterator(); // iterator while(i.hasNext()) System.out.print(" - " + i.next()); System.ot.println(); } public static void main(String [] arg) { LinkedList l = new LinkedList(); ArrayList a = new ArrayList(); l.add("lin1"); l.add("lin2"); l.add("lin3"); l.add("lin1"); l.add("lin1"); a.addAll(l); // kopiuje z L - > a Prog60.prt(a); // wypisuje z użyciem iteratora JAVA 2 w praktyce

JAVA – List : LinkedList i ArrayList Interfejs List – zachowuje kolejność elementów i dodaje nowe metody do interfejsu Collection, między innymi ListIterator pozwalający na przeglądanie listy w obu kierunkach i wstawiania i wyjmowania ze środka listy (zalecane dla LinkedList) ArrayList – najlepsza (szybka) w przypadku dostępu swobodnego do elementów LinkedList – szybkie wstawianie i usuwanie elementów,optymalny dostęp sekwencyjne do środka listy, posiada dodatkowe metody addFirst(), addLast(), getFirst(), getLast(), removeFirst(), removeLast() import java.util.*; public class Prog61{ public static void main(String [] arg) { LinkedList l = new LinkedList(); ArrayList a = new ArrayList(); l.add("lin3"); l.add("lin1"); l.add("lin2"); a.addAll(l); l.add(1,"lin1"); // na pozycję 1 int poz = l.indexOf("lin2"); // pozycja elementu ListIterator it = a.listIterator(); // start od początku it = a.listIterator(1); // start od pozycji 1 poz = a.lastIndexOf("lin1"); l.remove(2); //usuń element na pozycji 2 l.set(0,"mig"); // ustaw pozycje 0 na "mig" if(it.hasNext()) { Object t = it.next(); poz = it.nextIndex(); } if(it.hasPrevious()) { Object t = it.previous(); poz = it.previousIndex(); } it.add("su22"); it.set("tu154"); it.remove(); // usuń element } } //Prog61 JAVA 2 w praktyce

JAVA – Set : HashSet i TreeSet Interfejs Set – te same metody co interfejs Collection, ale różne zachowanie. Nie można przechowywać więcej niż jednego egzemplarza wartości każdego z obiektów. Elementy umieszczone w Set muszą definiować metodę equals() w celu możliwości ustalenia ich unikatowości. Set nie zapewnia utrzymywania obiektów w żadnym ustalonym porządku. (*)HashSet – dla zbiorów wymagających szybkiej lokalizacji elementu.Elementy muszą definiować metodę hashCode(). TreeSet – zbiór uporządkowany typu SortedSet, posiada metody comparator(), first(), last(), subSet(), headSet(), tailSet(). import java.util.*; class MyType implements Comparable { float f; String s; MyType(float a, String s) { this.s = s; f=a;} public boolean equals(Object o){ return (o instanceof MyType) && (f == ((MyType)o).f ) ; } public int hashCode() {return (int)f; } public int compareTo(Object o) { float ff = ((MyType)o).f ; return (ff > f? -1: (ff==f? 0:1) );} } equals - do ustalenia niepowtarzalności compareTo - do sortowania (kolejność) hashCode - dla tablic HashSet + equals public class Prog62{ public static void main(String [] arg) { Set a = new HashSet(); // Set a = new TreeSet(); a.add(new MyType(1.0f,"jeden")); a.add(new MyType(2.0f,"dwa")); a.add(new MyType(3.0f,"dwa")); // zgodnie z naszą //compareTo nie są te same a.add(new MyType(1.0f,"jeden")); // próba dodania tego //samego.. System.out.println(a.size()); // --> 3 } } //Prog62 JAVA 2 w praktyce

JAVA – TreeSet JAVA 2 w praktyce System.out.println(a.size()); // --> 4 System.out.println(a); // [ jeden 1.0, dwa 2.0, trzy 3.0, cztery 4.0 ] Object o1 = a.first(); // zwraca najmniejszy element Object o2 = a.last(); // zwraca największy element Iterator i = ((Collection)a).iterator(); Object m2 = i.next(); i.next(); Object m3 = i.next(); System.out.println(o1); System.out.println(o2); SortedSet a2 = a.subSet(m2,m3); // podzbiór od elem. do elem. < m3 System.out.println(a2); // [jeden 1.0, dwa 2.0 ] a2 = a.headSet(m3); // zwraca zbiór elementów < od podanego System.out.println(a2); // [jeden 1.0, dwa 2.0 ] a2 = a.tailSet(m3); // zwraca zbiór elementów > bądź == System.out.println(a2); // [trzy 3.0, cztery 4.0] } } //Prog63 import java.util.*; class MyType implements Comparable { float f; String s; MyType(float a, String s) { this.s = s; f=a;} public boolean equals(Object o){ return (o instanceof MyType) && (f == ((MyType)o).f ) ; } public int hashCode() {return (int)f; } public int compareTo(Object o) { float ff = ((MyType)o).f ; return (ff > f? -1: (ff==f? 0:1) ); } public String toString(){ return s + f; } } public class Prog63{ public static void main(String [] arg) { SortedSet a = new TreeSet(); a.add(new MyType(1.0f,"jeden")); a.add(new MyType(2.0f,"dwa")); a.add(new MyType(3.0f,"trzy")); a.add(new MyType(4.0f,"cztery")); JAVA 2 w praktyce

JAVA – Map: HashMap i TreeMap Interfejs Map – przechowuje pary klucz-wartość, można więc odnaleźć wartość podając klucz (*) HashMap – zalecana implementacja Map oparta na tablicy haszującej, wszystkie elementy muszą udostępniać metodę hashCode() TreeMap – zbiór typu SortedMap uporządkowany, posiada metody firstKey(), lastKey(), subMap(), headMap(), tailMap() import java.util.*; class Licznik { int i; public String toString(){ return " "+ i; } } public class Prog64{ public static void main(String [] arg) { HashMap ht = new HashMap(); Random ra = new Random(); for(int i = 0; i < 1000; i++) // losowanie liczby z zakresu 0-10 { Integer r = new Integer( Math.abs(ra.nextInt()%10) ); if ( ht.containsKey(r) ) // jeżeli jest klucz ((Licznik)ht.get(r)).i++; // zwiększ wartość else ht.put(r, new Licznik()); // jak nie ma załóż nowy klucz } System.out.println(ht); } //Prog64 JAVA 2 w praktyce

JAVA – implementacja Map dla kluczy własnych typów import java.util.*; class Subject implements Comparable { String s; float wsp; static int i; int nr ; Subject(String s, float w) {this.s = s; wsp = w; nr = i++; } public int hashCode() { return (int)wsp + s.hashCode() ; } public boolean equals(Object o) { return ((o instanceof Subject) && (s == ((Subject)o).s)); } public int compareTo(Object o) { String ss =( ((Subject)o).s); return( s.compareTo(ss)); } public String toString() { return " \n Subject["+ nr +"] " + s + "(" + wsp +")"; } } class Teacher { String s; int i; Teacher(String s, int i ) { this.s = s; this.i = i;} public String toString() { return s + " "+ i; } public boolean equals(Object o) { return ((o instanceof Teacher) && (s == ((Teacher)o).s) && (i == ((Teacher)o).i)); } } JAVA 2 w praktyce

JAVA – implementacja Map dla kluczy własnych typów public class Prog65{ public static void main(String [] arg) { HashMap ht = new HashMap(); //TreeMap ht = new TreeMap(); ht.put(new Subject("C++ ",4.0f), new Teacher("assistant",1)); ht.put(new Subject("Java ",5.0f), new Teacher("assistant",1)); ht.put(new Subject("Pascal ",3.0f), new Teacher("lecturer ",3)); ht.put(new Subject("Fortran",2.0f), new Teacher("professor",4)); ht.put(new Subject("Pascal ",4.0f), new Teacher("lecturer ",2)); // inny kod haszujący System.out.println("odwzorowanie klucz-wartosc "); System.out.println(ht); System.out.println("wartosci:\n "); // sprawdzenie czy zawiera wartość if (ht.containsValue(new Teacher("assistant",1))) // działa dzięki przesłonięciu equals() { Collection value = ht.values(); //wartości mogą się powtarzać stąd Collection System.out.println(value); } System.out.println("klucze:\n "); if (ht.containsKey(new Subject("Fortran",2.0f))) // działa dzięki przesłonięciu equals() Set key = ht.keySet(); // klucze są unikatowe zatem - Set System.out.println(key); key.removeAll(key); // zmiana kluczy zmienia odwzorowanie System.out.println(ht); // teraz puste }} } //Prog65 JAVA 2 w praktyce

JAVA – implementacja Map dla kluczy własnych typów Wersja Prog65 dla HashMap() Wersja Prog65 dla TreeMap() TreeMap() korzysta z compareTo(), i porządkuje elementy według String stąd Pascal 4.0 nie może być nowym kluczem JAVA 2 w praktyce

JAVA – implementacja Map dla kluczy własnych typów import java.util.*; class Subject implements Comparable { String s; float wsp; static int i; int nr ; Subject(String s, float w) {this.s = s; wsp = w; nr = i++; } public int compareTo(Object o) { String ss =( ((Subject)o).s); return( s.compareTo(ss)); } public String toString() { return " \n Subject["+ nr +"] " + s + "(" + wsp +")"; } } public class Prog66{ public static void main(String [] arg) { TreeMap ht = new TreeMap(); ht.put(new Subject("C++ ",4.0f),”1”); ht.put(new Subject("Java ",5.0f), ”2”); ht.put(new Subject("Pascal ",3.0f), ”3”); ht.put(new Subject("Fortran",2.0f), ”4”); ht.put(new Subject("Algol ",4.0f), ”5”); System.out.println("odwzorowanie klucz-wartość "); System.out.println(ht); Object small = ht.firstKey(); //pierwszy klucz System.out.println(small); Object high = ht.lastKey(); // ostatni klucz System.out.println(high); high = new Subject("Java ",5.0f); small = new Subject("C++ ",4.0f); SortedMap m1 = ht.subMap(small,high); // odwzorowanie o podzbiorze kluczy System.out.println(m1); // odwzorowanie o kluczach < od podanego m1 = ht.headMap(high); // odwzorowanie o kluczach > = od podanego m1 = ht.tailMap(small); }} //Prog66 JAVA 2 w praktyce

JAVA – niemodyfikowalne kontenery Collections i Map import java.util.*; class Subject implements Comparable { String s; float wsp; static int i; int nr ; Subject(String s, float w) {this.s = s; wsp = w; nr = i++; } public int compareTo(Object o) { String ss =( ((Subject)o).s); return( s.compareTo(ss)); } public String toString() { return " \n Subject["+ nr +"] " + s + "(" + wsp +")"; } } public class Prog67{ public static void main(String [] arg) { Map ht = new TreeMap(); ht.put(new Subject("C++ ",4.0f),"1"); ht = Collections.unmodifiableMap(ht); // ht.put(new Subject("C ",1.0f),"6"); zabronione }} //Prog67 Składnia dla Collection, Set i List: Collections. unmodifiableCollection(Collection c) Collections. unmodifiableList(List c) Collections. unmodifiableSet(Set c) JAVA 2 w praktyce

JAVA – obsługa błędów JAVA 2 w praktyce import java.util.*; // własna klasa wyjątku class MyException extends Exception { MyException() {} MyException(String message) { super(message);} } public class Prog68{ // definicja metody w której może wystąpić public static void function (int i) throws MyException { if (i == 1) throw new MyException(" jestem z f "); public static void main(String [] arg) { try { Prog68.function(1); } catch (MyException e) { System.out.println(" zlapalem swój"); // najpierw klasa pochodna } catch (Exception e) { System.out.println(" zlapalem "); // bazowa nie może być wcześniej } finally { // bo kod dla błędu typu MyException nie // byłby wykonywany System.out.println(" zlapalem czy nie to koniec"); } //Prog68 try { // blok chroniony ...............(tu może powstać wyjątek) } catch( Typwyjątku identyfikator) { } catch ( Typwyjątku identyfikator) { ........ } finally { czynności wykonywane za każdym razem } !! catch wykonywane jest tylko dla pierwszego pasującego JAVA 2 w praktyce

JAVA – klasa Exception JAVA 2 w praktyce Exception dziedziczy z Throwable zwracanie komunikatu: String getMessage() String getLocalizedMessage() opis Throwable łącznie dostępnymi szczegółami: String toString() ślad stosu wywołań: void printStackTrace() //std. wyjście void printStackTrace(PrintStream) // na podany strumień void printStackTrace(PrintWriter) // na podany strumień zapis w obiekcie Throwable informacje o stanie stosu: Throwable fillInStackTrace() import java.util.*; public class Prog69{ public static void main(String [] arg) { try { throw new Exception ("jestem wyjątkiem "); } catch (Exception e) { System.err.println(" getMessage = " + e.getMessage()) ; System.err.println(" getLMessage = " + e.getLocalizedMessage()); System.err.println(" toString = " + e); e.printStackTrace(System.err); } } //Prog69 JAVA 2 w praktyce

JAVA –wyrzucenie wyjątku na inny poziom import java.util.*; public class Prog70{ public static void f() throws Exception{ throw new Exception(" wygenerowany w f "); } public void fowner() throws Throwable { try{ f(); }catch (Exception e) { System.err.println("wewnątrz fowner "); e.printStackTrace(System.err); // przekazanie na wyższy poziom lub nowy Throwable A) throw e; B) // throw e.fillInStackTrace(); //nowy } } public static void main(String [] arg) throws Throwable{ try { Prog70 m = new Prog70(); m.fowner(); } catch (Exception e) { System.err.println("mam wyjątek w main"); e.printStackTrace(System.err); // ślad pamięta że e pochodzi z f() } }} //Prog70 A B JAVA 2 w praktyce

JAVA – wyjątki a przeciążanie import java.util.*; class AException extends Exception{} class BException extends Exception{} class CException extends Exception{} class SException extends AException{} interface First { void set() throws AException,BException; //void move() throws AException,BException; void open() throws AException; } class Second implements First { public void set() {System.out.println("");} // ok nic nie trzeba //zgłaszać // public void move() throws CException {} // nie można //dodawać niedziedziczących wyjątków public void open() throws SException {}; // taki można W metodzie przeciążonej można zgłaszać jedynie wyjątki z klasy podstawowej lub wyjątki które dziedziczą po wyjątkach klasy bazowej public class Prog71{ public static void main(String [] arg) { try { Second f = new Second(); f.set(); // f.move(); f.open(); } catch (Exception e) { System.err.println("mam wyjatek "); } } //Prog71 JAVA 2 w praktyce

JAVA – System wejścia - wyjścia : klasa File import java.io.*; import java.util.*; class DirFilter implements FilenameFilter{ // to klasa reprezentująca filtr String s; DirFilter(String s) { this.s = s;} public boolean accept(File dir, String name) { // obcięcie informacji o ścieżce String f = new File(name).getName(); // inaczej File x = new File(name); f = x.getName(); return f.indexOf(s) != -1; } // jeżeli dany podciąg nie występuje indexOf zwraca -1 } // zatem wynik false public class Prog72{ public static void main(String [] arg) { File path = new File("."); // ustawia na bieżący katalog String [] list; if( arg.length == 0 ) list = path.list(); // wszystkie pliki i katalogi else list = path.list(new DirFilter(arg[0])); // jeśli arg np "java” w list będą tylko // katalogi i pliki z takim ciągiem znaków w nazwie for(int i = 0; i < list.length; i++) // list używa funkcji accept System.out.println(list[i]); }} //Prog72 JAVA 2 w praktyce

JAVA – System wejścia - wyjścia: klasa File public class Prog73{ public static void fileHistory(String name) { File f = new File(name); System.out.println( " \nFile location: " + f.getAbsolutePath() + " \nRead ready ?: " + f.canRead() + " \nReadOnly ? : " + !(f.canWrite()) + " \nName : " + f.getName() + " \nParent ? : " + f.getParent() + " \nLength ? : " + f.length() + " \nModified ? : " + f.lastModified()); } public static void main(String [] arg) { File path; if (arg.length != 0) path = new File(arg[0]); // pobranie ścieżki katalogu else path = new File("."); // domyślnie bieżący String [] list; File current; list = path.list(); System.out.println(" Listing of " + path.getAbsolutePath()); for(int i = 0; i < list.length; i++){ current = new File(list[i]); if (current.isDirectory()) System.out.println("directory "+ list[i]); if (current.isFile()) Prog73.fileHistory(list[i]); } } //Prog73 JAVA 2 w praktyce

JAVA – System wejścia - wyjścia: klasa File if (arg.length == 3) { dpath = new File(arg[0]); f1path = new File(arg[0]+"\\"+arg[1]); f2path = new File(arg[0]+"\\"+arg[2]); try{ if (!dpath.exists()) dpath.mkdirs(); // tworzy katalog f1path.createNewFile(); File f3path = new File(arg[0]+"nowy.dat"); f3path.createNewFile(); // nowy plik f3path.renameTo(f2path); // zmiana nazwy } catch (IOException e ) { // wymagana obsługa System.err.println(" Error occur in block 1 " ); } System.out.println("listing:"); list = dpath.list(); for(int i =0; i< list.length;i++) System.out.println(list[i]); f1path.delete(); System.out.println("usunięte"); for(int i =0; i< list.length;i++) System.out.println(list[i]); }catch (Exception e ) { System.err.println(" Error occur in block 2 " ); } }}} //Prog74 import java.io.*; import java.util.*; class DirFilter implements FilenameFilter{ String s; DirFilter(String s) { this.s = s;} public boolean accept(File dir, String name) { String f = new File(name).getName(); return f.indexOf(s) != -1; } } public class Prog74{ public static void main(String [] arg) { File dpath, f1path, f2path; String [] list; JAVA 2 w praktyce

System.out jest opakowany w PrintStream !!! JAVA – System wejścia - wyjścia: hierarchia klas dla strumieni bajtowych InputStream (abstrakcyjna) OutputStream (abstrakcyjna) ByteArrayInputStream (tablica jako źródło) ByteArrayOutputStream(tworzy bufor w pamięci) StringBufferInputStream (string jako źródło) Deprecated!! FileInputStream (plik jako źródło) FileOutputStream PipedInputStream (potok w wielowątkowych) PipedOutputStream (potok w wielowątkowych) SequenceInputStream(konwersja dwóch strumieni w jeden) klasy dekoratory (zapewniające użyteczny interfejs): FilterInputStream (abstrakcyjna) FilterOutputStream(abstrakcyjna) DataInputStream (dla danych typu podstawowego) DataOutputStream BufferedInputStream (dla strumieni buforowanych) BufferedOutputStream PrintStream (formatuje dane wyjściowe) LineNumberInputStream (śledzi numery wierszy) PushbackInputStream (umożliwia cofanie do strumienia ostatniego znaku) System.out jest opakowany w PrintStream !!! JAVA 2 w praktyce

JAVA – System wejścia - wyjścia: strumienie bajtowe import java.io.*; import java.util.*; public class Prog75{ public static void main(String [] arg) { boolean zapis = true; try { FileOutputStream fileOut = new FileOutputStream("c:\\jdk\\moj.dat"); int [] dane = { 2, 45, 158 }; for(int i = 0; i<dane.length; i++) FileOut.write(dane[i]); fileOut.close(); } catch (IOException e ) { zapis = false; System.err.println("błąd zapisu"); } if(zapis) { FileInputStream fileInp = new FileInputStream("c:\\jdk\\moj.dat"); boolean eof = false; while(!eof) { int value = fileInp.read(); if (value != -1) System.out.println(" "+value); else eof = true; } fileInp.close(); } catch (IOException e ) { System.err.println("błąd odczytu"); } } } } //Prog75 Strumienie wyjścia powiązane z plikami nadpisują istniejące pliki !!!!! JAVA 2 w praktyce

JAVA – System wejścia - wyjścia: strumienie bajtowe import java.io.*; import java.util.*; public class Prog76{ public static void main(String [] arg) { boolean zapis = true; boolean eof = false; byte [] tablica = { 1,2,3,4,5,6,7,8,9,10 }; try { ByteArrayInputStream inp = new ByteArrayInputStream(tablica); FileOutputStream fileOut = new FileOutputStream("c:\\jdk\\moj.dat"); BufferedOutputStream bufOut = new BufferedOutputStream(fileOut); // fileout będzie buforowany bufOut.write(tablica[0]); //-> 1 bufOut.write(tablica,1,2); // z tablicy od elementu 1 zapisze 5 bajtów --> 2,3 eof = false; while(!eof) {byte value = (byte)inp.read(); // read zwraca w formacie int if (value != -1) bufOut.write(value); //-> 1,2,3,4,5,6,7,8,9,10 else eof = true; } bufOut.close(); } catch (IOException e ) { zapis = false; System.err.println("blad zapisu"); } if(zapis) { try { ByteArrayOutputStream out = new ByteArrayOutputStream(30); // tworzy 30 bajtowy bufor w pamięci BufferedInputStream bufInp = new BufferedInputStream(new FileInputStream("c:\\jdk\\moj.dat")); eof = false; while(!eof) { int value = bufInp.read(); if (value != -1) out.write(value) ; // zapis do bufora bufInp.close(); byte [] tab = out.toByteArray(); // utworzenie tablicy o zawartości bufora for(int i =0; i < tab.length; i++) System.out.println(tab[i]); } catch (IOException e ) { System.err.println("błąd odczytu"); } } } } //Prog76 JAVA 2 w praktyce

JAVA – System wejścia - wyjścia: strumienie bajtowe import java.io.*; import java.util.*; public class Prog77{ public static void main(String [] arg) { boolean zapis = true; try { FileOutputStream fileOut = new FileOutputStream("c:\\jdk\\moj.dat"); BufferedOutputStream bufOut = new BufferedOutputStream(fileOut); DataOutputStream dataOut = new DataOutputStream(bufOut); dataOut.writeInt(2); dataOut.writeBoolean(zapis); dataOut.writeUTF(" To koniec zawartości pliku"); dataOut.close(); } catch (IOException e ) { zapis = false; System.err.println("błąd zapisu"); } if(zapis) { try { DataInputStream dataInp = new DataInputStream(new BufferedInputStream(new FileInputStream("c:\\jdk\\moj.dat"))); if (dataInp.available() != 0){ // jeżeli plik zawiera jakieś bajty (nie jest pusty) int x = dataInp.readInt(); boolean b = dataInp.readBoolean(); String s = dataInp.readUTF(); System.out.println(" " + x + " " + b + " " + s); } dataInp.close(); } catch (IOException e ) { System.err.println("błąd odczytu"); } } }} //Prog77 readBoolean() writeBoolean(); readByte() writeByte() readShort() writeShort() readInt() writeInt() readLong() writeLong() readFloat() writeFloat() readDouble() writeDouble() readUTF() writeUTF() JAVA 2 w praktyce

JAVA – System wejścia - wyjścia: strumienie bajtowe import java.io.*; import java.util.*; public class Prog78{ public static void main(String [] arg) { boolean zapis = true; boolean eof = false; try { StringBufferInputStream st = new StringBufferInputStream("jestem strumieniem"); BufferedOutputStream bufOut = new BufferedOutputStream(new FileOutputStream("c:\\jdk\\moj.dat")); eof = false; while(!eof) { char znak = (char)st.read(); if (znak != (char)-1 ) bufOut.write((byte)znak); else eof = true; } bufOut.close(); } catch (IOException e ) { zapis = false; System.err.println("blad zapisu"); } if(zapis) { try { BufferedInputStream bufInp = new BufferedInputStream(new FileInputStream("c:\\jdk\\moj.dat")); while(!eof) { char znak = (char)((byte)bufInp.read()); if (znak != (char)-1) System.out.println(znak); bufInp.close(); } catch (IOException e ) { System.err.println("blad odczytu"); } } } } //Prog78 Uwaga ta klasa ma znacznik Deprecated!! JAVA 2 w praktyce

JAVA – System wejścia - wyjścia: strumienie bajtowe import java.io.*; import java.util.*; public class Prog79{ public static void main(String [] arg) { boolean zapis = true; try { PrintStream pout = new PrintStream(new BufferedOutputStream(new FileOutputStream("c:\\jdk\\moj.dat"))); pout.println(2.0); pout.println(3); pout.println('z'); pout.print(" to jest dobre "); pout.close(); } catch (IOException e ) { zapis = false; System.err.println("blad zapisu"); } if(zapis) { try { BufferedReader bufInp = new BufferedReader(new FileReader("c:\\jdk\\moj.dat")); // strumień znakowy !!! // zgodny z UNICODE String a,b,c,d; a = bufInp.readLine() ; b = bufInp.readLine() ; c = bufInp.readLine() ; d = bufInp.readLine() ; System.out.println(a + " " + b + " " + c + " " +d ); bufInp.close(); } catch (IOException e ) { System.err.println("blad odczytu"); } } }} //Prog79 Strumienie wyjścia powiązane z plikami nadpisują istniejące pliki !!!!! JAVA 2 w praktyce

JAVA – System wejścia - wyjścia: strumienie znakowe InputStream (abstrakcyjna) Reader (abstrakcyjna) ByteArrayInputStream (tablica jako źródło) CharArrayReader StringBufferInputStream (string jako źródło) Deprecated!! StringReader FileInputStream (plik jako źródło) FileReader PipedInputStream (potok w wielowątkowych) PipedReader OutputStream (abstrakcyjna) Writer (abstrakcyjna) ByteArrayOutputStream(tworzy bufor w pamięci) ByteArrayOutputStream(tworzy bufor w pamięci) - brak - StringWriter FileOutputStream FileWriter PipedOutputStream (potok w wielowątkowych) PipedWriter (potok w wielowątkowych) Konwersja: InputStream  (InputStreamReader  Reader OutputStream  (OutputStreamWriter)  Writer JAVA 2 w praktyce

JAVA – System wejścia - wyjścia: strumienie znakowe klasy dekoratory (zapewniające użyteczny interfejs): FilterInputStream (abstrakcyjna) FilterReader BufferedInputStream (dla strumieni buforowanych) BufferedReader LineNumberInputStream (śledzi numery wierszy) LineNumberReader PushbackInputStream (umożliwia cofanie ostatniego znaku) PushbackInputReader FilterOutputStream(abstrakcyjna) FilterWriter(abstrakcyjna) BufferedOutputStream (dla strumieni buforowanych) BufferedWriter PrintStream (formatuje dane wyjściowe) PrintWriter JAVA 2 w praktyce

JAVA – System wejścia - wyjścia: strumienie znakowe import java.io.*; import java.util.*; public class Prog80{ public static void main(String [] arg) { boolean zapis = true; try { PrintWriter bufOut = new PrintWriter(new BufferedWriter(new FileWriter("c:\\jdk\\moj2.dat"))); for(int i = 0; i < 5; i++) bufOut.println("nr " + i); bufOut.close(); } catch (IOException e ) { zapis = false; System.err.println("blad zapisu"); } if(zapis) { try { BufferedReader bufInp = new BufferedReader(new FileReader("c:\\jdk\\moj2.dat")); String [] tab = new String[100]; int i = 0; while((tab[i++] = bufInp.readLine()) != null); // czytanie liniami for(i = 0; tab[i]!=null ; i++) System.out.println(tab[i] ); bufInp.close(); } catch (IOException e ) { System.err.println("blad odczytu"); } } } } //Prog80 Strumienie wyjścia powiązane z plikami nadpisują istniejące pliki !!!!! JAVA 2 w praktyce

JAVA – System wejścia - wyjścia: strumienie znakowe import java.io.*; import java.util.*; public class Prog81{ public static void main(String [] arg) { boolean zapis = true; File fname = new File("c:\\jdk\\moj2.dat"); if (fname.exists() && fname.isFile()){ // sprawdzamy czy jest taki plik try { BufferedReader strInp = new BufferedReader(new StringReader(" jestem komunikatem ")); PrintWriter bufOut = new PrintWriter(new BufferedWriter(new FileWriter(fname))); bufOut.println(strInp.readLine()); bufOut.close(); } catch (IOException e ) { zapis = false; System.err.println("blad zapisu"); } if(zapis) { try { BufferedReader bufInp = new BufferedReader(new FileReader("c:\\jdk\\moj2.dat")); String [] tab = new String[100]; int i = 0; while((tab[i++] = bufInp.readLine()) != null); for(i = 0; tab[i]!=null ; i++) System.out.println(tab[i] ); bufInp.close(); } catch (IOException e ) { System.err.println("blad odczytu"); } } } //if }} //Prog81 FileWriter(String, ovveride Yes = true, No = false) FileWriter(”mój.dat”) - nadpisze plik FileWriter(”mój.dat”,false) - nadpisze plik FileWriter(”mój.dat”,true) - dopisze na koniec pliku JAVA 2 w praktyce

JAVA – System wejścia - wyjścia: System.in import java.io.*; import java.util.*; public class Prog83{ public static void main(String [] arg) { try{ // system.in to obiekt InputStream BufferedReader input = new BufferedReader(new InputStreamReader(System.in)); // konwertujemy na Reader String s,s1=new String(); System.out.println(" pisz co chcesz, pusty wiersz przerywa wczytywanie " ); while((s = input.readLine()).length() != 0 ) s1+=s+" "; System.out.println(s1); // system.out jest już opakowany w PrintStream System.out.print(" Podaj wiek : "); s =input.readLine(); int w = Integer.parseInt(s); System.out.print(" Podaj wzrost w metrach : "); double r = Double.parseDouble(s); System.out.println(" Masz lat: " + w + " i wzrostu " + r + " metra "); } catch (IOException e ) { System.err.println("czytaj polecenia !!");} }} //Prog83 JAVA 2 w praktyce

JAVA – System wejścia - wyjścia: strumienie bajtowe- pliki o dostępie swobodnym import java.io.*; import java.util.*; public class Prog82{ public static void main(String [] arg) { try { RandomAccessFile file = new RandomAccessFile("test.dat","rw"); // rw read and write for(int i = 0; i < 5; i++) { System.out.println(file.getFilePointer()); // 0,4,8,12,16 file.writeInt(i);} file.close(); RandomAccessFile file2 = new RandomAccessFile("test.dat","rw"); // rw read and write System.out.println(file2.getFilePointer()); // -> 0 pokazuje pozycje file2.seek(8); // -> ustaw od 8 bajtu int i = file2.readInt(); System.out.println(" odczytalem = " + i); // -> 2 file2.seek(20); file2.writeUTF("text"); String s = file2.readUTF(); System.out.println(" odczytalem = " + s); // -> text file2.close(); RandomAccessFile file3 = new RandomAccessFile("test.dat","r"); // r - read only file3.seek(12); i = file3.readInt(); System.out.println(" odczytalem ponownie= " + i); // - > 3 file3.close(); }catch(IOException e ) { System.err.println("blad"); } }} //Prog82 JAVA 2 w praktyce

JAVA – zmiana standardowych strumieni (przekierowanie) metody statyczne: System.setIn(InputStream); System.setOut(PrintStream); System.setErr(PrintStream); import java.io.*; import java.util.*; public class Prog84{ public static void main(String [] arg) throws IOException { BufferedInputStream input = new BufferedInputStream(new FileInputStream("Prog84.java")); PrintStream output = new PrintStream(new BufferedOutputStream(new FileOutputStream("wyniki.dat"))); System.setIn(input); System.setOut(output); System.setErr(output); BufferedReader read = new BufferedReader(new InputStreamReader(System.in)); String s; while((s=read.readLine())!= null) System.out.println(s); // czytamy z wejściowego i zapisujemy do wyjściowego output.close(); } } //Prog84 JAVA 2 w praktyce

JAVA – kompresja GZIP JAVA 2 w praktyce GZIPOutputStream(OutputStream) GZIPInputStream(InputStream) import java.io.*; import java.util.*; import java.util.zip.*; public class Prog85{ public static void main(String [] arg) throws IOException { BufferedInputStream input = new BufferedInputStream(new FileInputStream("Prog85.java")); BufferedOutputStream output = new BufferedOutputStream ( new GZIPOutputStream ( new FileOutputStream ("Prog85.gz"))); int bajt; while ((bajt = input.read()) != -1 ) output.write(bajt); input.close(); output.close(); BufferedReader input2 = new BufferedReader ( new InputStreamReader ( new GZIPInputStream ( new FileInputStream ("Prog85.gz")))); String s; while((s=input2.readLine())!= null) System.out.println(s); input2.close(); }} //Prog85 JAVA 2 w praktyce

JAVA – kompresja Zip: dodawanie do archiwum import java.io.*; import java.util.*; import java.util.zip.*; public class Prog86{ public static void main(String [] arg) throws IOException { FileOutputStream fileout = new FileOutputStream("testuj.zip"); // plik archiwum CheckedOutputStream sumaout = new CheckedOutputStream(fileout, new Adler32()); // dla sumy kontrolnej ZipOutputStream zipfileout = new ZipOutputStream( new BufferedOutputStream( sumaout)); String [] files = new String [] {new String("Prog85.java"), new String("Prog86.java") }; int bajt; for(int i = 0; i < files.length; i++) { BufferedInputStream inp = new BufferedInputStream( new FileInputStream(files[i])); ZipEntry ze = new ZipEntry(files[i]); zipfileout.putNextEntry(ze); // dodawanie do archiwum while ((bajt = inp.read())!= -1 ) zipfileout.write(bajt); inp.close(); } // for zipfileout.close(); System.out.println(" suma kontrolna = " + sumaout.getChecksum().getValue() ); // suma kontrolna }} //Prog86 JAVA 2 w praktyce

JAVA – kompresja Zip: odczyt z archiwum import java.io.*; import java.util.*; import java.util.zip.*; public class Prog87{ public static void main(String [] arg) throws IOException { FileInputStream fileinp = new FileInputStream("testuj.zip"); CheckedInputStream sumainp = new CheckedInputStream(fileinp, new Adler32()); ZipInputStream zipfileinp = new ZipInputStream( new BufferedInputStream( sumainp)); int bajt; ZipEntry ze; while((ze = zipfileinp.getNextEntry())!=null) { // odczyt składników (plików) System.out.println(" Rozpakowuje plik o nazwie " + ze); BufferedOutputStream out = new BufferedOutputStream ( new FileOutputStream(ze.getName())); // nazwa składnika(pliku) while((bajt = zipfileinp.read()) != -1) out.write(bajt); out.close(); } System.out.println(" suma kontrolna = " + sumainp.getChecksum().getValue() ); } //Prog87 JAVA 2 w praktyce