Java 3

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));
c.add("one");
System.out.println(c);
c2.add("one");
c2.add("two");
c2.add(new Integer(3));
c2.add("one");
System.out.println(c2);
// [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
JAVA 2 w praktyce
// [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
65
JAVA – kontenery a typy przechowywanych obiektów
import java.util.*;
class MyType {
float f = 3.3f; }
ArrayList można traktować jak tablicę o rozszerzalnej pojemności
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
JAVA 2 w praktyce
66
JAVA – inteligentny kontener dla klasy obiektów
import java.util.*;
public class Prog59 {
class MyType {
public static void main(String [] arg) {
float f = 3.3f;
MyType(float t) { f = t; }
MyTypeList m = new MyTypeList();
public float show(int nr) { return f; }
m.add(new MyType(2.1f));
}
m.add(new MyType(3.1f));
class MyTypeList {
System.out.println(" rozmiar = " + m.size()); // 2
private ArrayList a = new ArrayList();
System.out.println(m.show(0));
// 2.1
public void add(MyType t) { a.add(t); }
public MyType get(int nr) { return (MyType)a.get(nr); }
t = m.get(0);
public int size() { return a.size(); }
public float show(int nr) { return ((MyType)a.get(nr)).f; }
}
MyType t = new MyType(0.2f);
System.out.println(t.show(0));
// 2.1
}
} //Prog59
JAVA 2 w praktyce
67
JAVA –implementacja metod interfejsu Collection
System.out.println(a);
import java.util.*;
Object [] ob = l.toArray(); // zwraca Object [] z elem. kontenera
public class Prog60 {
System.out.println(ob.length);
public static void prt(Collection c) {
Iterator i = c.iterator();
// tak jak w l
//--> 5
String [] s = (String [])l.toArray(new String [1]); // zwrot tab []
// iterator
while(i.hasNext())
System.out.print(" - " + i.next());
System.ot.println();
}
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);
public static void main(String [] arg) {
// usuń wszystkie argumenty z l które są w a
a.add("lin3");
LinkedList l = new LinkedList();
l.retainAll(a);
ArrayList a = new ArrayList();
// część wspólna zbiorów pozostanie w l
System.out.println(l.size() + " " + l); // -> 1 [lin3]
l.add("lin1"); l.add("lin2"); l.add("lin3");
l.add("lin1"); l.add("lin1");
System.out.println(l.contains("lin3")); // czy zawiera element -> true
System.out.println(l.contains(a)); // czy zbiór a jest podzbiorem l? –
//-> false
a.addAll(l);
Prog60.prt(a);
// kopiuje z L - > a
// wypisuje z użyciem iteratora
} } //Prog60
JAVA 2 w praktyce
68
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.*;
poz = a.lastIndexOf("lin1");
public class Prog61{
public static void main(String [] arg) {
l.remove(2);
//usuń element na pozycji 2
l.set(0,"mig");
// ustaw pozycje 0 na "mig"
if(it.hasNext()) {
LinkedList l = new LinkedList();
Object t = it.next(); poz = it.nextIndex(); }
ArrayList a = new ArrayList();
if(it.hasPrevious()) {
Object t = it.previous(); poz = it.previousIndex(); }
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
it.add("su22");
it.set("tu154");
it.remove();
// usuń element
} } //Prog61
JAVA 2 w praktyce
69
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
70
JAVA – TreeSet
System.out.println(a.size());
System.out.println(a);
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{
Object o1 = a.first();
Object o2 = a.last();
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"));
a2 = a.tailSet(m3);
System.out.println(a2);
// --> 4
// [ jeden 1.0, dwa 2.0, trzy 3.0, cztery 4.0 ]
// zwraca najmniejszy element
// 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);
System.out.println(a2);
// zwraca zbiór elementów < od podanego
// [jeden 1.0, dwa 2.0 ]
// zwraca zbiór elementów > bądź ==
// [trzy 3.0, cztery 4.0]
}
} //Prog63
JAVA 2 w praktyce
71
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();
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
Random ra = new Random();
JAVA 2 w praktyce
72
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 +")"; }
}
JAVA 2 w praktyce
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)); }
}
73
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));
System.out.println("odwzorowanie klucz-wartosc ");
System.out.println(ht);
System.out.println("wartosci:\n ");
if (ht.containsValue(new Teacher("assistant",1)))
{
Collection value = ht.values();
System.out.println(value);
}
System.out.println("klucze:\n ");
if (ht.containsKey(new Subject("Fortran",2.0f)))
{
Set key = ht.keySet();
System.out.println(key);
key.removeAll(key);
System.out.println("odwzorowanie klucz-wartosc ");
System.out.println(ht);
}} } //Prog65
JAVA 2 w praktyce
// inny kod haszujący
// sprawdzenie czy zawiera wartość
// działa dzięki przesłonięciu equals()
//wartości mogą się powtarzać stąd Collection
// działa dzięki przesłonięciu equals()
// klucze są unikatowe zatem - Set
// zmiana kluczy zmienia odwzorowanie
// teraz puste
74
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
75
JAVA – implementacja Map dla kluczy własnych typów
System.out.println("odwzorowanie klucz-wartość ");
System.out.println(ht);
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”);
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);
System.out.println(small);
System.out.println(high);
SortedMap m1 = ht.subMap(small,high);
// odwzorowanie o podzbiorze kluczy
System.out.println(m1);
// odwzorowanie o kluczach < od podanego
m1 = ht.headMap(high);
System.out.println(m1);
// odwzorowanie o kluczach > = od podanego
m1 = ht.tailMap(small);
System.out.println(m1);
}} //Prog66
JAVA 2 w praktyce
76
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{
Składnia dla Collection, Set i List:
Collections. unmodifiableCollection(Collection c)
Collections. unmodifiableList(List c)
Collections. unmodifiableSet(Set c)
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
JAVA 2 w praktyce
77
JAVA – obsługa błędów
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);
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
} 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");
}
}
JAVA 2 w praktyce
} //Prog68
78
JAVA – klasa Exception
Exception dziedziczy z Throwable
import java.util.*;
zwracanie komunikatu:
public class Prog69{
public static void main(String [] arg) {
String getMessage()
String getLocalizedMessage()
opis Throwable łącznie dostępnymi szczegółami:
try {
throw new Exception ("jestem wyjątkiem ");
String toString()
ślad stosu wywołań:
} 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
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()
JAVA 2 w praktyce
79
JAVA –wyrzucenie wyjątku na inny poziom
import java.util.*;
A
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);
B
// 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
JAVA 2 w praktyce
80
JAVA – wyjątki a przeciążanie
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
import java.util.*;
class AException extends Exception{}
class BException extends Exception{}
class CException extends Exception{}
public class Prog71{
class SException extends AException{}
public static void main(String [] arg) {
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("");}
//zgłaszać
// public void move() throws CException {}
//dodawać niedziedziczących wyjątków
public void open() throws SException {};
}
try {
Second f = new Second();
f.set();
// f.move();
f.open();
// ok nic nie trzeba
// nie można
// taki można
JAVA 2 w praktyce
} catch (Exception e) {
System.err.println("mam wyjatek ");
}
}
} //Prog71
81
JAVA – System wejścia - wyjścia : klasa File
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; }
}
// to klasa reprezentująca filtr
// obcięcie informacji o ścieżce
// inaczej File x = new File(name); f = x.getName();
// 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(".");
String [] list;
if( arg.length == 0 )
list = path.list();
else
list = path.list(new DirFilter(arg[0]));
for(int i = 0; i < list.length; i++)
System.out.println(list[i]);
}} //Prog72
// ustawia na bieżący katalog
// wszystkie pliki i katalogi
// jeśli arg np "java” w list będą tylko
// katalogi i pliki z takim ciągiem znaków w nazwie
// list używa funkcji accept
JAVA 2 w praktyce
82
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]); }
}
JAVA 2 w praktyce
} //Prog73
83
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]);
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;
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 " ); }
try{
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");
list = dpath.list();
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
JAVA 2 w praktyce
84
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)
JAVA 2 w praktyce
System.out jest opakowany w
PrintStream !!!
85
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;
Strumienie wyjścia powiązane z plikami nadpisują istniejące
pliki !!!!!
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) {
try {
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
JAVA 2 w praktyce
86
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
else eof = true; }
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]);
JAVA 2odczytu");
w praktyce
87
} catch (IOException e ) { System.err.println("błąd
}}
} } //Prog76
JAVA – System wejścia - wyjścia: strumienie bajtowe
import java.io.*; import java.util.*;
public class Prog77{
public static void main(String [] arg) {
readBoolean()
writeBoolean();
readByte()
writeByte()
readShort()
boolean zapis = true;
readInt()
try {
FileOutputStream fileOut = new FileOutputStream("c:\\jdk\\moj.dat"); readLong()
BufferedOutputStream bufOut = new BufferedOutputStream(fileOut);
readFloat()
DataOutputStream dataOut = new DataOutputStream(bufOut);
dataOut.writeInt(2);
readDouble()
dataOut.writeBoolean(zapis);
readUTF()
dataOut.writeUTF(" To koniec zawartości pliku");
dataOut.close();
} catch (IOException e ) { zapis = false; System.err.println("błąd zapisu"); }
writeShort()
writeInt()
writeLong()
writeFloat()
writeDouble()
writeUTF()
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
JAVA 2 w praktyce
88
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;
Uwaga ta klasa ma znacznik Deprecated!!
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"));
eof = false;
while(!eof) {
char znak = (char)((byte)bufInp.read());
if (znak != (char)-1) System.out.println(znak);
else eof = true; }
bufInp.close();
} catch (IOException e ) { System.err.println("blad odczytu"); } }
}
} //Prog78
JAVA 2 w praktyce
89
JAVA – System wejścia - wyjścia: strumienie bajtowe
import java.io.*;
Strumienie wyjścia powiązane z plikami nadpisują istniejące
import java.util.*;
pliki !!!!!
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"));
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"); } }
JAVA 2 w praktyce
}} //Prog79
// strumień znakowy !!!
// zgodny z UNICODE
90
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
91
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
92
JAVA – System wejścia - wyjścia: strumienie znakowe
import java.io.*; import java.util.*;
public class Prog80{
public static void main(String [] arg) {
Strumienie wyjścia powiązane z plikami nadpisują istniejące
pliki !!!!!
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
JAVA 2 w praktyce
93
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()){
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
// 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"); } }
JAVA 2 w praktyce
} //if
}} //Prog81
94
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 : ");
s =input.readLine();
double r = Double.parseDouble(s);
System.out.println(" Masz lat: " + w + " i wzrostu " + r + " metra ");
} catch (IOException e ) { System.err.println("czytaj polecenia !!");}
JAVA 2 w praktyce
}} //Prog83
95
JAVA – System wejścia - wyjścia: strumienie bajtowepliki 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");
for(int i = 0; i < 5; i++) {
System.out.println(file.getFilePointer());
file.writeInt(i);}
file.close();
RandomAccessFile file2 = new RandomAccessFile("test.dat","rw");
System.out.println(file2.getFilePointer());
file2.seek(8);
int i = file2.readInt(); System.out.println(" odczytalem = " + i); // -> 2
file2.seek(20);
file2.writeUTF("text");
file2.seek(20);
String s = file2.readUTF(); System.out.println(" odczytalem = " + s);
file2.close();
RandomAccessFile file3 = new RandomAccessFile("test.dat","r");
file3.seek(12);
i = file3.readInt();
System.out.println(" odczytalem ponownie= " + i);
file3.close();
JAVA 2 w
}catch(IOException e ) { System.err.println("blad");
} praktyce
}} //Prog82
// rw read and write
// 0,4,8,12,16
// rw read and write
// -> 0 pokazuje pozycje
// -> ustaw od 8 bajtu
// -> text
// r - read only
// - > 3
96
JAVA – zmiana standardowych strumieni
(przekierowanie)
metody statyczne:
import java.io.*;
import java.util.*;
System.setIn(InputStream);
System.setOut(PrintStream);
System.setErr(PrintStream);
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
97
JAVA – kompresja GZIP
import java.io.*; import java.util.*;
import java.util.zip.*;
public class Prog85{
public static void main(String [] arg) throws IOException {
GZIPOutputStream(OutputStream)
GZIPInputStream(InputStream)
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();
JAVA 2 w praktyce
}} //Prog85
98
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");
CheckedOutputStream sumaout = new CheckedOutputStream(fileout, new Adler32());
// plik archiwum
// 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);
while ((bajt = inp.read())!= -1 ) zipfileout.write(bajt);
inp.close();
} // for
zipfileout.close();
System.out.println(" suma kontrolna = " + sumaout.getChecksum().getValue() );
JAVA 2 w praktyce
}} //Prog86
// dodawanie do archiwum
// suma kontrolna
99
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) {
System.out.println(" Rozpakowuje plik o nazwie " + ze);
// odczyt składników (plików)
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
100