Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00463 010165 11041354 na godz. na dobę w sumie
Java. Techniki zaawansowane. Wydanie VIII - książka
Java. Techniki zaawansowane. Wydanie VIII - książka
Autor: , Liczba stron: 1064
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-1483-7 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> java - programowanie
Porównaj ceny (książka, ebook (-84%), audiobook).

Co spowodowało, że język programowania Java zyskał tak wielką popularność? Przyczyn jest kilka: możliwość przenoszenia kodu między programami, wydajność i to, co programiści lubią najbardziej - mechanizm automatycznego oczyszczania pamięci. Nie bez znaczenia jest również to, że Java jest językiem zorientowanym obiektowo, udostępnia obsługę programowania rozproszonego oraz świetną dokumentację. Ponadto liczne publikacje oraz pomocna społeczność sprawiają, że Java zajmuje poczesne miejsce wśród innych języków programowania.

Kolejne wydanie książki 'Java. Techniki zaawansowane. Wydanie VIII' zostało zaktualizowane o wszystkie te elementy, które pojawiły się w wersji szóstej platformy Java Standard Edition. Dzięki tej książce dowiesz się, w jaki sposób wykorzystać strumienie, jak parsować dokumenty XML czy też w jaki sposób tworzyć aplikacje sieciowe. Poznasz interfejs JDBC, sposób wykorzystania transakcji oraz wykonywania zapytań SQL. Autorzy w szczegółowy sposób pokażą Ci, jak tworzyć aplikacje z wykorzystaniem biblioteki Swing. Dodatkowo przedstawią, w jaki sposób zapewnić bezpieczeństwo w tworzonych przez Ciebie aplikacjach. Wszystkie te - oraz wiele innych - zagadnienia zostaną przedstawione w przystępny i sprawdzony sposób!

Wykorzystaj zaawansowane możliwości języka Java w swoich projektach!

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

Java. Techniki zaawansowane. Wydanie VIII Autor: Cay S. Horstmann, Gary Cornell T³umaczenie: Jaromir Senczyk ISBN: 978-83-246-1483-7 Tytu³ orygina³u: Core Java(tm), Volume II--Advanced Features: Eighth Edition Format: 172x245, stron: 1064 • Jak wykorzystaæ strumienie? • Jak stworzyæ efektowny interfejs u¿ytkownika? • Jak zapewniæ bezpieczeñstwo w tworzonych aplikacjach? Co spowodowa³o, ¿e jêzyk programowania Java zyska³ tak wielk¹ popularnoœæ? Przyczyn jest kilka: mo¿liwoœæ przenoszenia kodu miêdzy programami, wydajnoœæ i to, co programiœci lubi¹ najbardziej – mechanizm automatycznego oczyszczania pamiêci. Nie bez znaczenia jest równie¿ to, ¿e Java jest jêzykiem zorientowanym obiektowo, udostêpnia obs³ugê programowania rozproszonego oraz œwietn¹ dokumentacjê. Ponadto liczne publikacje oraz pomocna spo³ecznoœæ sprawiaj¹, ¿e Java zajmuje poczesne miejsce wœród innych jêzyków programowania. Kolejne wydanie ksi¹¿ki „Java. Techniki zaawansowane. Wydanie VIII” zosta³o zaktualizowane o wszystkie te elementy, które pojawi³y siê w wersji szóstej platformy Java Standard Edition. Dziêki tej ksi¹¿ce dowiesz siê, w jaki sposób wykorzystaæ strumienie, jak parsowaæ dokumenty XML czy te¿ w jaki sposób tworzyæ aplikacje sieciowe. Poznasz interfejs JDBC, sposób wykorzystania transakcji oraz wykonywania zapytañ SQL. Autorzy w szczegó³owy sposób poka¿¹ Ci, jak tworzyæ aplikacje z wykorzystaniem biblioteki Swing. Dodatkowo przedstawi¹, w jaki sposób zapewniæ bezpieczeñstwo w tworzonych przez Ciebie aplikacjach. Wszystkie te – oraz wiele innych – zagadnienia zostan¹ przedstawione w przystêpny i sprawdzony sposób! • Wykorzystanie strumieni • Dokumenty XML i ich wykorzystanie w jêzyku Java • Programowanie aplikacji sieciowych • Wykorzystanie interfejsu JDBC • Tworzenie aplikacji wielojêzycznych • Mo¿liwoœci pakietu Swing • Wykorzystanie biblioteki AWT • Bezpieczeñstwo w aplikacjach • Zastosowanie podpisu cyfrowego • Sposoby wykorzystania obiektów rozproszonych (RMI) Wykorzystaj zaawansowane mo¿liwoœci jêzyka Java w swoich projektach! Spis treÊci Przedmowa ...............................................................................................................................................11 PodziÂkowania .........................................................................................................................................15 RozdziaÄ 1. Strumienie i pliki ....................................................................................................................17 Strumienie ................................................................................................................... 17 Odczyt i zapis bajtów ............................................................................................... 18 Zoo peäne strumieni ................................................................................................ 20 ãñczenie filtrów strumieni ........................................................................................ 24 Strumienie tekstowe ..................................................................................................... 27 Zapisywanie tekstu ................................................................................................. 28 Wczytywanie tekstu ................................................................................................. 31 Zapis obiektów w formacie tekstowym ...................................................................... 31 Zbiory znaków ......................................................................................................... 35 Odczyt i zapis danych binarnych ..................................................................................... 40 Strumienie plików o swobodnym dostöpie ................................................................. 43 Strumienie plików ZIP ................................................................................................... 48 Strumienie obiektów i serializacja .................................................................................. 55 Format pliku serializacji obiektów ............................................................................. 61 Modyfikowanie domyĈlnego mechanizmu serializacji .................................................. 67 Serializacja singletonów i wyliczeþ ............................................................................ 70 Wersje ................................................................................................................... 71 Serializacja w roli klonowania ................................................................................... 73 Zarzñdzanie plikami ...................................................................................................... 75 Ulepszona obsäuga wejĈcia i wyjĈcia .............................................................................. 82 Mapowanie plików w pamiöci ................................................................................... 82 Struktura bufora danych .......................................................................................... 89 Blokowanie plików ................................................................................................... 91 WyraĔenia regularne ..................................................................................................... 93 RozdziaÄ 2. JÂzyk XML ...........................................................................................................................103 Wprowadzenie do jözyka XML ...................................................................................... 104 Struktura dokumentu XML ..................................................................................... 106 Parsowanie dokumentów XML ..................................................................................... 109 4 Java. Techniki zaawansowane Kontrola poprawnoĈci dokumentów XML ...................................................................... 120 Definicje typów dokumentów .................................................................................. 122 XML Schema ........................................................................................................ 129 Praktyczny przykäad ............................................................................................... 131 Wyszukiwanie informacji i XPath .................................................................................. 145 Przestrzenie nazw ....................................................................................................... 151 Parsery strumieniowe ................................................................................................. 154 Wykorzystanie parsera SAX .................................................................................... 154 Wykorzystanie parsera StAX ................................................................................... 159 Tworzenie dokumentów XML ....................................................................................... 163 Tworzenie dokumentu XML za pomocñ parsera StAX ................................................ 167 Przeksztaäcenia XSL ................................................................................................... 174 RozdziaÄ 3. Programowanie aplikacji sieciowych ...............................................................................185 Poäñczenia z serwerem ............................................................................................... 185 Limity czasu gniazd ............................................................................................... 190 Adresy internetowe ............................................................................................... 191 Implementacja serwerów ............................................................................................ 193 Obsäuga wielu klientów .......................................................................................... 196 Poäñczenia czöĈciowo zamkniöte ............................................................................ 200 Przerywanie dziaäania gniazd sieciowych .................................................................. 201 Wysyäanie poczty elektronicznej ................................................................................... 207 Poäñczenia wykorzystujñce URL .................................................................................... 212 URL i URI ............................................................................................................. 212 Zastosowanie klasy URLConnection do pobierania informacji ................................... 214 Wysyäanie danych do formularzy ............................................................................. 224 RozdziaÄ 4. Poľczenia do baz danych: JDBC .......................................................................................233 Architektura JDBC ...................................................................................................... 234 Typy sterowników JDBC ......................................................................................... 235 Typowe zastosowania JDBC ................................................................................... 236 Jözyk SQL .................................................................................................................. 237 Instalacja JDBC .......................................................................................................... 243 Adresy URL baz danych ......................................................................................... 243 Pliki JAR zawierajñce sterownik .............................................................................. 244 Uruchamianie bazy danych ..................................................................................... 244 Rejestracja klasy sterownika .................................................................................. 245 Nawiñzywanie poäñczenia z bazñ danych ................................................................. 246 Wykonywanie poleceþ jözyka SQL ........................................................................... 248 Zarzñdzanie poäñczeniami, poleceniami i zbiorami wyników ....................................... 251 Analiza wyjñtków SQL ............................................................................................ 252 Wypeänianie bazy danych ....................................................................................... 255 Wykonywanie zapytaþ ................................................................................................. 258 Polecenia przygotowane ........................................................................................ 259 Odczyt i zapis duĔych obiektów ............................................................................... 267 Sekwencje sterujñce ............................................................................................. 269 Zapytania o wielu zbiorach wyników ........................................................................ 270 Pobieranie wartoĈci kluczy wygenerowanych automatycznie ...................................... 271 Przewijalne i aktualizowalne zbiory wyników zapytaþ ...................................................... 272 Przewijalne zbiory wyników ..................................................................................... 272 Aktualizowalne zbiory rekordów .............................................................................. 274 Spis treÊci 5 Zbiory rekordów .......................................................................................................... 279 Buforowane zbiory rekordów ................................................................................... 279 Metadane .................................................................................................................. 282 Transakcje ................................................................................................................. 292 Punkty kontrolne ................................................................................................... 293 Aktualizacje wsadowe ............................................................................................ 293 Zaawansowane typy jözyka SQL ............................................................................. 295 Zaawansowane zarzñdzanie poäñczeniami .................................................................... 297 Wprowadzenie do LDAP .............................................................................................. 298 Konfiguracja serwera LDAP .................................................................................... 299 Dostöp do informacji katalogu LDAP ....................................................................... 303 RozdziaÄ 5. Internacjonalizacja .............................................................................................................315 Lokalizatory ............................................................................................................... 316 Formaty liczb .............................................................................................................. 321 Waluty .................................................................................................................. 326 Data i czas ................................................................................................................ 328 Porzñdek alfabetyczny ................................................................................................. 335 Moc uporzñdkowania ............................................................................................. 337 Rozkäad ................................................................................................................ 337 Formatowanie komunikatów ........................................................................................ 343 Formatowanie z wariantami .................................................................................... 345 Pliki tekstowe i zbiory znaków ...................................................................................... 347 Internacjonalizacja a pliki Ēródäowe programów ........................................................ 347 Komplety zasobów ..................................................................................................... 348 Lokalizacja zasobów .............................................................................................. 349 Pliki wäaĈciwoĈci ................................................................................................... 350 Klasy kompletów zasobów ..................................................................................... 351 Kompletny przykäad .................................................................................................... 353 RozdziaÄ 6. Zaawansowane moÑliwoÊci pakietu Swing ......................................................................367 Listy .......................................................................................................................... 367 Komponent JList ................................................................................................... 368 Modele list ........................................................................................................... 374 Wstawianie i usuwanie .......................................................................................... 379 Odrysowywanie zawartoĈci listy .............................................................................. 381 Tabele ....................................................................................................................... 386 Najprostsze tabele ................................................................................................ 386 Modele tabel ........................................................................................................ 390 Wiersze i kolumny ................................................................................................. 394 Drzewa ...................................................................................................................... 421 Najprostsze drzewa ............................................................................................... 422 Przeglñdanie wözäów .............................................................................................. 438 Rysowanie wözäów ................................................................................................. 440 Nasäuchiwanie zdarzeþ w drzewach ........................................................................ 443 Wäasne modele drzew ........................................................................................... 450 Komponenty tekstowe ................................................................................................ 458 ćledzenie zmian zawartoĈci komponentów tekstowych ............................................. 459 Sformatowane pola wejĈciowe ............................................................................... 463 Komponent JSpinner ............................................................................................. 479 Prezentacja HTML za pomocñ JEditorPane .............................................................. 487 6 Java. Techniki zaawansowane WskaĒniki postöpu ..................................................................................................... 494 Paski postöpu ...................................................................................................... 494 Monitory postöpu .................................................................................................. 498 Monitorowanie postöpu strumieni wejĈcia ............................................................... 501 Organizatory komponentów ......................................................................................... 507 Panele dzielone .................................................................................................... 507 Panele z zakäadkami .............................................................................................. 511 Panele pulpitu i ramki wewnötrzne .......................................................................... 518 Rozmieszczenie kaskadowe i sñsiadujñce ............................................................... 521 Zgäaszanie weta do zmiany wäaĈciwoĈci .................................................................. 529 RozdziaÄ 7. Zaawansowane moÑliwoÊci biblioteki AWT ......................................................................537 Potokowe tworzenie grafiki .......................................................................................... 538 Figury ........................................................................................................................ 540 Wykorzystanie klas obiektów graficznych ................................................................. 542 Pola .......................................................................................................................... 555 ćlad pödzla ................................................................................................................ 556 Wypeänienia ............................................................................................................... 564 Przeksztaäcenia ukäadu wspóärzödnych ......................................................................... 566 Przycinanie ................................................................................................................ 571 PrzezroczystoĈè i skäadanie obrazów ............................................................................ 573 Wskazówki operacji graficznych ................................................................................... 581 Czytanie i zapisywanie plików graficznych ..................................................................... 587 Wykorzystanie obiektów zapisu i odczytu plików graficznych ...................................... 588 Odczyt i zapis plików zawierajñcych sekwencje obrazów ............................................ 592 Operacje na obrazach ................................................................................................. 598 Dostöp do danych obrazu ...................................................................................... 598 Filtrowanie obrazów ............................................................................................... 604 Drukowanie ............................................................................................................... 613 Drukowanie grafiki ................................................................................................ 614 Drukowanie wielu stron ......................................................................................... 623 Podglñd wydruku ................................................................................................... 624 Usäugi drukowania ................................................................................................. 633 Usäugi drukowania za poĈrednictwem strumieni ....................................................... 637 Atrybuty drukowania .............................................................................................. 638 Schowek ................................................................................................................... 644 Klasy i interfejsy umoĔliwiajñce przekazywanie danych ............................................. 645 Przekazywanie tekstu ............................................................................................ 646 Interfejs Transferable i formaty danych ................................................................... 650 Przekazywanie obrazów za pomocñ schowka ........................................................... 652 Wykorzystanie lokalnego schowka do przekazywania referencji obiektów ................... 657 Wykorzystanie schowka systemowego do przekazywania obiektów Java ..................... 657 Zastosowanie lokalnego schowka do przekazywania referencji obiektów .................... 661 Mechanizm „przeciñgnij i upuĈè” ................................................................................. 662 Przekazywanie danych pomiödzy komponentami Swing ............................................. 664 đródäa przeciñganych danych .................................................................................. 667 Cele upuszczanych danych ..................................................................................... 670 Integracja z macierzystñ platformñ ............................................................................... 678 Ekran powitalny .................................................................................................... 678 Uruchamianie macierzystych aplikacji pulpitu .......................................................... 683 Zasobnik systemowy ............................................................................................. 688 Spis treÊci 7 RozdziaÄ 8. JavaBeans ..........................................................................................................................693 Dlaczego ziarnka? ...................................................................................................... 694 Proces tworzenia ziarnek JavaBeans ............................................................................ 696 Wykorzystanie ziarnek do tworzenia aplikacji ................................................................ 698 Umieszczanie ziarnek w plikach JAR ....................................................................... 699 Korzystanie z ziarnek ............................................................................................. 700 Wzorce nazw wäaĈciwoĈci ziarnek i zdarzeþ ................................................................... 705 Typy wäaĈciwoĈci ziarnek ............................................................................................. 709 WäaĈciwoĈci proste ............................................................................................... 709 WäaĈciwoĈci indeksowane ...................................................................................... 710 WäaĈciwoĈci powiñzane ......................................................................................... 710 WäaĈciwoĈci ograniczone ....................................................................................... 712 Klasa informacyjna ziarnka .......................................................................................... 719 Edytory wäaĈciwoĈci .................................................................................................... 722 Implementacja edytora wäaĈciwoĈci ........................................................................ 726 Indywidualizacja ziarnka .............................................................................................. 733 Implementacja klasy indywidualizacji ...................................................................... 735 TrwaäoĈè ziarnek JavaBeans ........................................................................................ 742 Zastosowanie mechanizmu trwaäoĈci JavaBeans dla dowolnych danych ..................... 746 Kompletny przykäad zastosowania trwaäoĈci JavaBeans ............................................ 752 RozdziaÄ 9. BezpieczeÆstwo .................................................................................................................763 ãadowanie klas .......................................................................................................... 764 Hierarchia klas äadowania ...................................................................................... 766 Zastosowanie procedur äadujñcych w roli przestrzeni nazw ........................................ 768 Implementacja wäasnej procedury äadujñcej ............................................................. 769 Weryfikacja kodu maszyny wirtualnej ............................................................................ 774 MenedĔery bezpieczeþstwa i pozwolenia ...................................................................... 779 Bezpieczeþstwo na platformie Java ........................................................................ 781 Pliki polityki bezpieczeþstwa .................................................................................. 784 Tworzenie wäasnych klas pozwoleþ ......................................................................... 790 Implementacja klasy pozwoleþ ............................................................................... 792 Uwierzytelnianie uĔytkowników ............................................................................... 798 Moduäy JAAS ......................................................................................................... 804 Podpis cyfrowy ........................................................................................................... 813 Skróty wiadomoĈci ................................................................................................ 814 Podpisywanie wiadomoĈci ..................................................................................... 820 Certyfikaty X.509 .................................................................................................. 822 Weryfikacja podpisu .............................................................................................. 823 Problem uwierzytelniania ....................................................................................... 825 Podpisywanie certyfikatów ..................................................................................... 827 ēñdania certyfikatu ............................................................................................... 829 Podpisywanie kodu ..................................................................................................... 830 Podpisywanie plików JAR ....................................................................................... 830 Certyfikaty twórców oprogramowania ...................................................................... 835 Szyfrowanie ............................................................................................................... 837 Szyfrowanie symetryczne ....................................................................................... 837 Generowanie klucza .............................................................................................. 839 Strumienie szyfrujñce ............................................................................................ 843 Szyfrowanie kluczem publicznym ............................................................................ 844 8 Java. Techniki zaawansowane RozdziaÄ 10. Obiekty rozproszone .........................................................................................................851 Role klienta i serwera ................................................................................................. 852 Wywoäania zdalnych metod .......................................................................................... 854 Namiastka i szeregowanie parametrów ................................................................... 854 Model programowania RMI .......................................................................................... 856 Interfejsy i implementacje ...................................................................................... 856 Rejestr RMI .......................................................................................................... 858 Przygotowanie wdroĔenia ....................................................................................... 861 Rejestrowanie aktywnoĈci RMI ............................................................................... 864 Parametry zdalnych metod i wartoĈci zwracane ............................................................. 866 Przekazywanie obiektów zdalnych ........................................................................... 866 Przekazywanie obiektów, które nie sñ zdalne ........................................................... 866 Dynamiczne äadowanie klas ................................................................................... 868 Zdalne referencje obiektów o wielu interfejsach ....................................................... 873 Zdalne obiekty i metody equals, hashCode oraz clone ............................................. 874 Aktywacja zdalnych obiektów ....................................................................................... 874 Usäugi sieciowe i JAX-WS ............................................................................................. 880 Stosowanie JAX-WS ............................................................................................... 881 Klient usäugi Web .................................................................................................. 884 Usäuga Amazon ..................................................................................................... 886 RozdziaÄ 11. Skrypty, kompilacja i adnotacje .......................................................................................893 Skrypty na platformie Java .......................................................................................... 893 Wybór silnika skryptów .......................................................................................... 894 Przekierowanie wejĈcia i wyjĈcia ............................................................................. 897 Wywoäywanie funkcji i metod skryptów .................................................................... 898 Kompilacja skryptu ................................................................................................ 900 Przykäad: skrypty i graficzny interfejs uĔytkownika ..................................................... 901 Interfejs kompilatora .................................................................................................. 905 Kompilacja w najprostszy sposób ........................................................................... 906 Stosowanie zadaþ kompilacji ................................................................................. 906 Przykäad: dynamiczne tworzenie kodu w jözyku Java ................................................. 911 Stosowanie adnotacji ................................................................................................. 916 Przykäad — adnotacje obsäugi zdarzeþ .......................................................................... 918 Skäadnia adnotacji ...................................................................................................... 922 Adnotacje standardowe .............................................................................................. 926 Adnotacje kompilacji ............................................................................................. 927 Adnotacje zarzñdzania zasobami ............................................................................ 928 Metaadnotacje ...................................................................................................... 928 Przetwarzanie adnotacji w kodzie Ēródäowym ................................................................. 931 InĔynieria kodu bajtowego ........................................................................................... 937 Modyfikacja kodu bajtowego podczas äadowania ...................................................... 943 RozdziaÄ 12. Metody macierzyste .........................................................................................................947 Wywoäania funkcji jözyka C z programów w jözyku Java .................................................. 948 Numeryczne parametry metod i wartoĈci zwracane ........................................................ 954 Wykorzystanie funkcji printf do formatowania liczb ................................................... 955 ãaþcuchy znaków jako parametry ................................................................................. 956 Dostöp do skäadowych obiektu .................................................................................... 961 Dostöp do pól instancji .......................................................................................... 962 Dostöp do pól statycznych ..................................................................................... 965 Spis treÊci 9 Sygnatury .................................................................................................................. 966 Wywoäywanie metod jözyka Java .................................................................................. 967 Wywoäywanie metod obiektów ................................................................................ 968 Wywoäywanie metod statycznych ............................................................................. 972 Konstruktory ......................................................................................................... 973 Alternatywne sposoby wywoäywania metod .............................................................. 973 Tablice ...................................................................................................................... 975 Obsäuga bäödów ......................................................................................................... 978 Interfejs programowy wywoäaþ jözyka Java .................................................................... 983 Kompletny przykäad: dostöp do rejestru systemu Windows ............................................. 988 Rejestr systemu Windows ...................................................................................... 988 Interfejs dostöpu do rejestru na platformie Java ...................................................... 990 Implementacja dostöpu do rejestru za pomocñ metod macierzystych ........................ 990 Skorowidz ............................................................................................................................................1005 1 Strumienie i pliki W tym rozdziale: Q strumienie, Q strumienie tekstowe, Q odczyt i zapis danych binarnych, Q strumienie plików ZIP, Q strumienie obiektów i serializacja, Q zarządzanie plikami, Q ulepszona obsáuga wejĞcia i wyjĞcia, Q wyraĪenia regularne. W tym rozdziale omówimy metody obsáugi plików i katalogów, a takĪe metody zapisywa- nia do i wczytywania informacji z plików w formacie tekstowym i binarnym. W rozdziale przedstawiony jest równieĪ mechanizm serializacji obiektów, który umoĪliwia przechowy- wanie obiektów z taką áatwoĞcią, z jaką przechowujesz tekst i dane numeryczne. NastĊpnie omówimy szereg ulepszeĔ, które do obsáugi wejĞcia i wyjĞcia wprowadziá pakiet java.nio udostĊpniony w wersji Java SE 1.4. Rozdziaá zakoĔczymy przedstawieniem problematyki wyraĪeĔ regularnych, mimo Īe nie jest ona bezpoĞrednio związana ze strumieniami i pli- kami. Nie potrafiliĞmy jednak znaleĨü dla niej lepszego miejsca w ksiąĪce. W naszym wybo- rze nie byliĞmy zresztą osamotnieni, poniewaĪ zespóá Javy doáączyá specyfikacjĊ interfejsów programowych związanych z przetwarzaniem wyraĪeĔ regularnych do specyfikacji ulepszo- nej obsáugi wejĞcia i wyjĞcia w Java SE 1.4. Strumienie W jĊzyku Java obiekt, z którego moĪemy odczytaü sekwencjĊ bajtów, nazywamy strumieniem wejĞcia. Obiekt, do którego moĪemy zapisaü sekwencjĊ bajtów, nazywamy strumieniem wyjĞcia. ħródáem bądĨ celem tych sekwencji bajtów mogą byü, i czĊsto wáaĞnie są, pliki, 18 Java. Techniki zaawansowane ale takĪe i poáączenia sieciowe, a nawet bloki pamiĊci. Klasy abstrakcyjne InputStream i Out ´putStream stanowią bazĊ hierarchii klas opisujących wejĞcie i wyjĞcie programów Java. PoniewaĪ strumienie binarne nie są zbyt wygodne do manipulacji danymi przechowywanymi w standardzie Unicode (przypomnijmy tutaj, Īe Unicode opisuje kaĪdy znak za pomocą dwóch bajtów), stworzono osobną hierarchiĊ klas operujących na znakach Unicode i dziedziczących po klasach abstrakcyjnych Reader i Writer. Klasy te są przystosowane do wykonywania ope- racji odczytu i zapisu, opartych na dwubajtowych znakach Unicode, nie przydają siĊ nato- miast do znaków jednobajtowych. Odczyt i zapis bajtów Klasa InputStream posiada metodĊ abstrakcyjną: abstract int read() Metoda ta wczytuje jeden bajt i zwraca jego wartoĞü lub –1, jeĪeli natrafi na koniec Ĩródáa danych. Projektanci konkretnych klas strumieni wejĞcia przeáadowują tĊ metodĊ, dostarcza- jąc w ten sposób uĪytecznej funkcjonalnoĞci. Dla przykáadu, w klasie FileInputStream metoda read czyta jeden bajt z pliku. System.in to predefiniowany obiekt klasy pochodnej od Input ´Stream, pozwalający pobieraü informacje z klawiatury. Klasa InputStream posiada równieĪ nieabstrakcyjną metodĊ pozwalającą pobraü lub zigno- rowaü tablicĊ bajtów. Metody te wywoáują abstrakcyjna metodĊ read, tak wiĊc podklasy muszą przeáadowaü tylko tĊ jedną metodĊ. Analogicznie, klasa OutputStream definiuje metodĊ abstrakcyjną abstract void write(int b) która wysyáa jeden bajt do aktualnego wyjĞcia. Metody read i write potrafią zablokowaü wątek, dopóki dany bajt nie zostanie wczytany lub zapisany. Oznacza to, Īe jeĪeli strumieĔ nie moĪe natychmiastowo wczytaü lub zapisaü danego bajta (zazwyczaj z powodu powolnego poáączenia sieciowego), Java zawiesza wątek doko- nujący wywoáania. DziĊki temu inne wątki mogą wykorzystaü czas procesora, w którym wywoáana metoda czeka na udostĊpnienie strumienia. Metoda available pozwala sprawdziü liczbĊ bajtów, które w danym momencie odczytaü. Oznacza to, Īe poniĪszy kod prawdopodobnie nigdy nie zostanie zablokowany: int bytesAvaible = System.in.available(); if (bytesAvaible 0) { byte[] dane = new byte[bytesAvaible]; System.in.read(data); } Gdy skoĔczymy odczytywaü albo zapisywaü dane do strumienia, zamykamy go, wywoáując metodĊ close. Metoda ta uwalnia zasoby systemu operacyjnego, do tej pory udostĊpnione wątkowi. JeĪeli aplikacja otworzy zbyt wiele strumieni, nie zamykając ich, zasoby systemu RozdziaÄ 1. Q Strumienie i pliki 19 mogą zostaü naruszone. Co wiĊcej, zamkniĊcie strumienia wyjĞcia powoduje opróĪnienie bufora uĪywanego przez ten strumieĔ — wszystkie znaki, przechowywane tymczasowo w buforze, aby mogáy zostaü zapisane w jednym wiĊkszym pakiecie, zostaną natychmiast wysáane. JeĪeli nie zamkniemy strumienia, ostatni pakiet bajtów moĪe nigdy nie dotrzeü do odbiorcy. Bufor moĪemy równieĪ opróĪniü wáasnorĊcznie, przy uĪyciu metody flush. Mimo iĪ klasy strumieni udostĊpniają konkretne metody wykorzystujące funkcje read i write, programiĞci Javy rzadko z nich korzystają, poniewaĪ nieczĊsto siĊ zdarza, Īeby programy musiaáy czytaü i zapisywaü sekwencje bajtów. Dane, którymi jesteĞmy zwykle bardziej zain- teresowani, to liczby, áaĔcuchy znaków i obiekty. Java udostĊpnia wiele klas strumieni pochodzących od podstawowych klas InputStream i OutputStream, które pozwalają operowaü na danych w sposób bardziej dogodny aniĪeli w przypadku pracy na poziomie pojedynczych bajtów. java.io.InputStream 1.0 Q abstract int read() pobiera jeden bajt i zwraca jego wartoĞü. Metoda read zwraca –1, gdy natrafi na koniec strumienia. Q int read(byte[] b) wczytuje dane do tablicy i zwraca liczbĊ wczytanych bajtów, a jeĪeli natrafi na koniec strumienia, zwraca –1. Metoda read czyta co najwyĪej b.length bajtów. Q int read(byte[] b, int off, int len) wczytuje dane do tablicy bajtów. Zwraca liczbĊ wczytanych bajtów, a jeĪeli natrafi na koniec strumienia, zwraca –1. Parametry: b off tablica, w której zapisywane są dane. indeks tablicy b, pod którym powinien zostaü umieszczony pierwszy wczytany bajt. maksymalna liczba wczytywanych bajtów. len Q long skip(long n) ignoruje n bajtów w strumieniu wejĞcia. Zwraca faktyczną liczbĊ zignorowanych bajtów (która moĪe byü mniejsza niĪ n, jeĪeli natrafimy na koniec strumienia). Q int available() zwraca liczbĊ bajtów dostĊpnych bez koniecznoĞci zablokowania wątku (pamiĊtajmy, Īe zablokowanie oznacza, Īe wykonanie aktualnego wątku zostaje wstrzymane). Q void close() zamyka strumieĔ wejĞcia. Q void mark(int readlimit) ustawia znacznik na aktualnej pozycji strumienia wejĞcia (nie wszystkie strumienie obsáugują tĊ moĪliwoĞü). JeĪeli ze strumienia zostaáo pobranych wiĊcej niĪ readlimit bajtów, strumieĔ ma prawo usunąü znacznik. 20 Java. Techniki zaawansowane Q void reset() wraca do ostatniego znacznika. PóĨniejsze wywoáania read bĊdą powtórnie czytaü pobrane juĪ bajty. JeĪeli znacznik nie istnieje, strumieĔ nie zostanie zresetowany. Q boolean markSupported() zwraca true, jeĪeli strumieĔ obsáuguje znaczniki. java.io.OutputStream 1.0 Q abstract void write(int n) zapisuje jeden bajt. Q void write(byte[] b) Q void write(byte[] b, int off, int len) zapisują wszystkie bajty tablicy b lub pewien ich zakres. Parametry: b off tablica, z której pobierane są dane. indeks tablicy b, spod którego powinien zostaü pobrany pierwszy zapisywany bajt. liczba zapisywanych bajtów. len Q void close() opróĪnia i zamyka strumieĔ wyjĞcia. Q void flush() opróĪnia strumieĔ wyjĞcia, czyli wysyáa do odbiorcy wszystkie dane znajdujące siĊ w buforze. Zoo peÄne strumieni W przeciwieĔstwie do jĊzyka C, który w zupeánoĞci zadowala siĊ jednym typem FILE*, Java posiada istne zoo ponad 60 (!) róĪnych typów strumieni (patrz rysunki 1.1 i 1.2). Podzielmy gatunki naleĪące do zoo klas strumieni zaleĪnie od ich przeznaczenia. Istnieją osobne hierarchie klas przetwarzających bajty i znaki. Jak juĪ o tym wspomnieliĞmy, klasy InputStream i OutputStream pozwalają pobieraü i wysy- áaü jedynie pojedyncze bajty oraz tablice bajtów. Klasy te stanowią bazĊ hierarchii pokazanej na rysunku 1.1. Do odczytu i zapisu liczb i áaĔcuchów znakowych uĪywamy ich podklas. Na przykáad, DataInputStream i DataOutputStream pozwalają wczytywaü i zapisywaü wszyst- kie podstawowe typy Javy w postaci binarnej. Istnieje wiele poĪytecznych klas strumieni, na przykáad ZipInputStream i ZipOutputStream pozwalające odczytywaü i zapisywaü dane w plikach skompresowanych w formacie ZIP. Z drugiej strony, o czym juĪ wspominaliĞmy, do obsáugi tekstu Unicode uĪywamy klas pocho- dzących od klas abstrakcyjnych Reader i Writer (patrz rysunek 1.2) Podstawowe metody klas Reader i Writer są podobne do tych naleĪących do InputStream i OutputStream. RozdziaÄ 1. Q Strumienie i pliki 21 Rysunek 1.1. Hierarchia strumieni wejĈcia i wyjĈcia abstract int read() abstract void write(int b) Metoda read zwraca albo kod znaku Unicode (jako liczbĊ z przedziaáu od 0 do 65535), albo –1, jeĪeli natrafi na koniec pliku. Metoda write jest wywoáywana dla podanego kodu znaku Unicode (wiĊcej informacji na temat kodów Unicode znjadziesz w rozdziale 3. ksiąĪki Java 2. Podstawy). 22 Java. Techniki zaawansowane Rysunek 1.2. Hierarchia klas Reader i Writer Począwszy od Java SE 5.0, wprowadzono cztery dodatkowe interfejsy: Closeable, Flushable, Readable i Appendable (patrz rysunek 1.3). Pierwsze dwa z nich są wyjątkowo proste i zawie- rają odpowiednio metody: void close() throws IOException i void flush() Klasy InputStream, OutputStream, Reader i Writer implementują interfejs Closeable. Klasy OutputStream i Writer implementują interfejs Flushable. Interfejs Readable ma tylko jedną metodĊ int read(CharBuffer cb) Klasa CharBuffer ma metody do sekwencyjnego oraz swobodnego odczytu i zapisu. Repre- zentuje ona bufor w pamiĊci lub mapĊ pliku w pamiĊci. (Patrz punkt „Struktura bufora da- nych” na stronie 89). Interfejs Appendable ma dwie metody umoĪlwiające dopisywanie pojedynczego znaku bądĨ sekwencji znaków: Appendable append(char c) Appendable append(CharSequence s) RozdziaÄ 1. Q Strumienie i pliki 23 Rysunek 1.3. Interfejsy Closeable, Flushable, Readable i Appendable Interfejs CharSequence opisuje podstawowe wáaĞciwoĞci sekwencji wartoĞci typu char. Inter- fejs ten implementują klasy String, CharBuffer, StringBuilder i StringBuffer. SpoĞród klas strumieni jedynie klasa Writer implementuje interfejs Appendable. java.io.Closeable 5.0 Q void close() zamyka obiekt implemetujący interfejs Closeable. MoĪe wyrzuciü wyjątek IOException. java.io.Flushable 5.0 Q void flush() opróĪnia bufor danych związany z obiektem implementującym interfejs Flushable. java.lang.Readable 5.0 Q int read(CharBuffer cb) próbuje wczytaü tyle wartoĞci typu char, ile moĪe pomieĞciü cb. Zwraca liczbĊ wczytanych wartoĞci lub -1, jeĞli obiekt Readable nie ma juĪ wartoĞci do pobrania. java.lang.Appendable 5.0 Q Appendable append(char c) 24 Java. Techniki zaawansowane Q Appendable append(CharSequence cs) dopisuje podany kod znaku lub wszystkie kody podanej sekwencji do obiektu Appendable; zwraca this. java.lang.CharSequence 1.4 Q char charAt(int index) zwraca kod o podanym indeksie. Q int length() zwraca liczbĊ kodów w sekwencji. Q CharSequence subSequence(int startIndex, int endIndex) zwraca sekwencjĊ CharSequence záoĪoną z kodów od startIndex do endIndex - 1. Q String toString() zwraca áaĔcuch znaków skáadający siĊ z kodów danej sekwencji. þczenie filtrów strumieni Klasy FileInputStream i FileOutputStream obsáugują strumienie wejĞcia i wyjĞcia przypo- rządkowane okreĞlonemu plikowi na dysku. W konstruktorze tych klas podajemy nazwĊ pliku lub peáną ĞcieĪkĊ dostĊpu do niego. Na przykáad FileInputStream fin = new FileInputStream( employee.dat ); spróbuje odszukaü w aktualnym katalogu plik o nazwie employee.dat. PoniewaĔ wszystkie klasy w java.io uznajñ relatywne ĈcieĔki dostöpu za rozpoczy- najñce siö od aktualnego katalogu roboczego, powinieneĈ wiedzieè, co to za kata- log. MoĔesz pobraè tö informacjö poleceniem System.getProperty( user.dir ). Tak jak klasy abstrakcyjne InputStream i OutputStream, powyĪsze klasy obsáugują odczyt i zapis plików na poziomie pojedynczego bajta. Oznacza to, Īe z obiektu fin moĪemy czytaü wyáącznie pojedyncze bajty oraz tablice bajtów. byte b = (byte)fin.read(); W nastĊpnym podrozdziale przekonamy siĊ, Īe korzystając z DataInputStream, moglibyĞmy wczytywaü typy liczbowe: DataInputStream din = . . .; double p = din.readDouble(); Ale tak jak FileInputStream nie posiada metod czytających typy liczbowe, tak DataInput ´Stream nie posiada metody pozwalającej czytaü dane z pliku. Java korzysta ze sprytnego mechanizmu rozdzielającego te dwa rodzaje funkcjonalnoĞci. Niektóre strumienie (takie jak FileInputStream i strumieĔ wejĞcia zwracany przez metodĊ openStream klasy URL) mogą udostĊpniaü bajty z plików i innych, bardziej egzotycznych loka- RozdziaÄ 1. Q Strumienie i pliki 25 lizacji. Inne strumienie (takie jak DataInputStream i PrintWriter) potrafią tworzyü z bajtów reprezentacjĊ bardziej uĪytecznych typów danych. Programista Javy musi poáączyü te dwa mechanizmy w jeden. Dla przykáadu, aby wczytywaü liczby z pliku, powinien utworzyü obiekt typu FileInputStream, a nastĊpnie przekazaü go konstruktorowi DataInputStream. FileInputStream fin = new FileInputStream( employee.dat ); DataInputStream din = new DataInputStream(fin); double s = din.readDouble(); Wróümy do rysunku 1.1, gdzie przedstawione są klasy FilterInputStream i FilterOutput ´Stream. Ich podklasy moĪemy wykorzystaü do rozbudowy obsáugi strumieni zwykáych bajtów. RóĪne funkcjonalnoĞci moĪemy dodawaü poprzez zagnieĪdĪanie filtrów. Na przykáad — domyĞlnie strumienie nie są buforowane. Wobec tego kaĪde wywoáanie metody read oznacza odwoáanie siĊ do usáug systemu operacyjnego, który odczytuje kolejny bajt. DuĪo efektyw- niej bĊdzie Īądaü od systemu operacyjnego caáych bloków danych i umieszczaü je w buforze. JeĞli chcemy uzyskaü buforowany dostĊp do pliku, musimy skorzystaü z poniĪszej, mon- strualnej sekwencji konstruktorów: DataInputStream din = new DataInputStream (new BufferedInputStream (new FileInputStream( employee.dat ))); Zwróümy uwagĊ, Īe DataInputStream znalazá siĊ na ostatnim miejscu w áaĔcuchu konstrukto- rów, poniewaĪ chcemy uĪywaü metod klasy DataInputStream i chcemy, aby korzystaáy one z buforowanej metody read. Czasami bĊdziemy zmuszeni utrzymywaü áącznoĞü ze strumieniami znajdującymi siĊ poĞrodku áaĔcucha. Dla przykáadu, czytając dane, musimy czĊsto podejrzeü nastĊpny bajt, aby spraw- dziü, czy jego wartoĞü zgadza siĊ z naszymi oczekiwaniami. W tym celu Java dostarcza klasĊ PushbackInputStream. PushbackInputStream pbin = new PushbackInputStream (new BufferedInputStream (new FileInputStream( employee.dat ))); Teraz moĪemy odczytaü wartoĞü nastĊpnego bajta: int b = pbin.read(); i umieĞciü go z powrotem w strumieniu, jeĪeli jego wartoĞü nie odpowiada naszym oczeki- waniom. if (b != ) pbin.unread(b); Ale wczytywanie i powtórne wstawianie to jedyne metody obsáugiwane przez klasĊ Push ´back-InputStream. JeĪeli chcemy podejrzeü kolejne bajty, a takĪe wczytywaü liczby, potrze- bujemy referencji zarówno do PushbackInputStream, jak i do DataInputStream. DataInputStream din = DataInputStream (pbin = new PushbackInputStream (new BufferedInputStream (new FileInputStream( employee.dat )))); 26 Java. Techniki zaawansowane OczywiĞcie, w bibliotekach strumieni innych jĊzyków programowania takie udogodnienia jak buforowanie i kontrolowanie kolejnych bajtów są wykonywane automatycznie, wiĊc koniecz- noĞü tworzenia ich kombinacji w jĊzyku Java wydaje siĊ niepotrzebnym zawracaniem gáowy. Jednak moĪliwoĞü áączenia klas filtrów i tworzenia w ten sposób naprawdĊ uĪytecznych sekwencji strumieni daje nam niespotykaną elastycznoĞü. Na przykáad, korzystając z poniĪ- szej sekwencji strumieni, moĪemy wczytywaü liczby ze skompresowanego pliku ZIP (patrz rysunek 1.4). ZipInputStream zin = new ZipInputStream(new FileInputStream( employee.zip )); DataInputStream din = new DataInputStream(zin); Rysunek 1.4. Sekwencja filtrowanych strumieni Aby dowiedzieü siĊ wiĊcej o obsáudze formatu ZIP, zajrzyj do podrozdziaáu poĞwiĊconego strumieniom plików ZIP na stronie 48. java.io.FileInputStream 1.0 Q FileInputStream(String name) tworzy nowy obiekt typu FileInputStream, uĪywając pliku, którego ĞcieĪka dostĊpu znajduje siĊ w áaĔcuchu nazwa. Q FileInputStream(File file) tworzy nowy obiekt typu FileInputStream, uĪywając pliku, którego ĞcieĪkĊ dostĊpu zawiera parametr name, lub uĪywając informacji zawartych w obiekcie file (klasa File zostanie omówiona pod koniec tego rozdziaáu). ĝcieĪki dostĊpu są podawane wzglĊdem katalogu roboczego skonfigurowanego podczas uruchamiania maszyny wirtualnej Java. java.io.FileOutputStream 1.0 Q FileOutputStream(String name) Q FileOutputStream(String name, boolean append) Q FileOutputStream(File file) tworzy nowy obiekt typu RozdziaÄ 1. Q Strumienie i pliki 27 Q FileOutputStream(File file, boolean append) tworzy nowy strumieĔ wyjĞciowy pliku okreĞlonego za pomocą áaĔcucha file lub obiektu file (klasa File zostanie omówiona pod koniec tego rozdziaáu). JeĪeli parametr append ma wartoĞü true, dane doáączane są na koĔcu pliku, a istniejący plik o tej samej nazwie nie zostanie skasowany. W przeciwnym razie istniejący plik o tej samej nazwie zostanie skasowany. java.io.BufferedInputStream 1.0 Q BufferedInputStream(InputStream in) tworzy nowy obiekt typu BufferedInputStream, o domyĞlnym rozmiarze bufora. StrumieĔ buforowany wczytuje znaki ze strumienia danych, nie wymuszając za kaĪdym razem dostĊpu do urządzenia. Gdy bufor zostanie opróĪniony, system przeĞle do niego nowy blok danych. java.io.BufferedOutputStream 1.0 Q BufferedOutputStream(OutputStream out) tworzy nowy obiekt typu Buffered-OutputStream, o domyĞlnym rozmiarze bufora. StrumieĔ umieszcza w buforze znaki, które powinny zostaü zapisane, nie wymuszając za kaĪdym razem dostĊpu do urządzenia. Gdy bufor zapeáni siĊ lub gdy strumieĔ zostanie opróĪniony, dane są przesyáane odbiorcy. java.io.PushbackInputStream 1.0 Q PushbackInputStream(InputStream in) tworzy strumieĔ sprawdzający wartoĞü nastĊpnego w kolejce bajta. Q PushbackInputStream(InputStream we, int size) tworzą strumieĔ umoĪliwiający podgląd kolejnego bajta wraz z buforem o podanym rozmiarze. Q void unread(int b) wstawia bajt z powrotem do strumienia, dziĊki czemu przy nastĊpnym wywoáaniu read zostanie on ponownie odczytany. Parametry: zwracany bajt b Strumienie tekstowe Zapisując dane, moĪemy wybieraü pomiĊdzy formatem binarnym i tekstowym. Dla przykáadu: jeĪeli liczba caákowita 1234 zostanie zapisana w postaci binarnej, w pliku pojawi siĊ sekwencja bajtów 00 00 04 D2 (w notacji szesnastkowej). W formacie tekstowym liczba ta zostanie zapisana jako áaĔcuch 1234 . Mimo iĪ zapis danych w postaci binarnej jest szybki i efektywny, to uzyskany wynik jest kompletnie nieczytelny dla ludzi. W poniĪszym podrozdziale skoncen- trujemy siĊ na tekstowym wejĞciu-wyjĞciu. 28 Java. Techniki zaawansowane Zapisując áaĔcuchy znakowe, musimy uwzglĊdniü sposób kodowania znaków. W przypad- ku kodowania UTF-16 áaĔcuch 1234 zostanie zakodowany jako 00 31 00 32 00 33 00 34 (w notacji szesnastkowej). JednakĪe obecnie wiĊkszoĞü Ğrodowisk, w których uruchamiamy programy w jĊzyku Java, uĪywa swojego wáasnego formatu tekstu. W kodzie ISO 8859-1, najczĊĞciej stosowanym w USA i Europie Zachodniej, nasz przykáadowy áaĔcuch zostanie zapisany jako 31 32 33 34, bez bajtów o wartoĞci zero. Klasa OutputStreamWriter zamienia strumieĔ znaków Unicode na strumieĔ bajtów, stosując odpowiednie kodowanie znaków. Natomiast klasa InputStreamReader zamienia strumieĔ wejĞcia, zawierający bajty (reprezentujące znaki za pomocą okreĞlonego kodowania), na obiekt udostĊpniający znaki Unicode. PoniĪej przedstawiamy sposób utworzenia obiektu wejĞcia, wczytującego znaki z konsoli i automatycznie konwertującego je na Unicode. InputStreamReader in = new InputStreamReader(System.in); Obiekt wejĞcia korzysta z domyĞlnego kodowania lokalnego systemu, na przykáad ISO 8859-1 MoĪemy wybraü inny sposób kodowania, podając jego nazwĊ w konstruktorze InputStream ´Reader, na przykáad: InputStreamReader in = new InputStreamReader(new FileInputStream( kremlin.dat ), ´ ISO8859_5 ); WiĊcej informacji na temat kodowania znaków znajdziesz w punkcie „Zbiory znaków” na stronie 35. PoniewaĪ obiekty tekstowego wejĞcia i wyjĞcia są tak czĊsto doáączane do plików, Java dostar- cza w tym celu dwie wygodne klasy: FileReader i FileWriter. Na przykáad instrukcja FileWriter out = new FileWriter( output.txt ); jest równoznaczna z FileWriter out = new FileWriter(new FileOutputStream( output.txt ); Zapisywanie tekstu W celu zapisania tekstu korzystamy z klasy PrintWriter. Dysponuje ona metodami umoĪ- liwiającymi zapis áaĔcuchów i liczb w formacie tekstowym. Dla wygody programistów ma ona konstruktor umoĪliwiający poáączenie obiektu klasy PrintWriter z FileWriter. Zatem instrukcja PrintWriter out = new PrintWriter( employee.txt ); stanowi odpowiednik instrukcji PrintWriter out = new PrintWriter(new FileWriter( employee.txt )); Do zapisywania danych za pomocą obiektu klasy PrintWriter uĪywamy tych samych metod print i println, których uĪywaliĞmy dotąd z obiektem System.out. MoĪemy wykorzystywaü je do zapisu liczb (int, short, long, float, double), znaków, wartoĞci logicznych, áaĔcuchów znakowych i obiektów. RozdziaÄ 1. Q Strumienie i pliki 29 Spójrzmy na poniĪszy kod: String name = Harry Hacker ; double salary = 75000; out.print(name); out.print( ); out.println(salary); Rezultatem jego wykonania bĊdzie wysáanie napisu Harry Hacker 75000.0 do strumienia out. NastĊpnie znaki zostaną skonwertowane na bajty i zapisane w pliku employee.txt. Metoda println automatycznie dodaje znak koĔca wiersza, odpowiedni dla danego systemu operacyjnego ( w systemie Windows, w Unix). Znak koĔca wiersza moĪemy pobraü, stosując wywoáanie System.getProperty( line.separator ). JeĪeli obiekt zapisu znajduje siĊ w trybie automatycznego opróĪniania, w chwili wywoáania metody println wszystkie znaki w buforze zostaną wysáane do odbiorcy (obiekty PrintWriter zawsze są buforowane). DomyĞlnie automatyczne opróĪnianie jest wyáączone. Automaty- czne opróĪnianie moĪemy wáączaü i wyáączaü przy uĪyciu konstruktora PrintWriter(Writer out, boolean autoFlush: PrintWriter out = new PrintWriter(new FileWriter( employee.txt , true); // automatyczne opróľnianie Metody print nie wyrzucają wyjątków. Aby sprawdziü, czy ze strumieniem jest wszystko w porządku, wywoáujemy metodĊ checkError. Weterani Javy prawdopodobnie zastanawiajñ siö, co siö staäo z klasñ PrintStream i obiektem System.out. W jözyku Java 1.0 klasa PrintStream obcinaäa znaki Unicode do znaków ASCII, po prostu opuszczajñc górny bajt. Takie rozwiñzanie nie pozwalaäo na przenoszenie kodu na inne platformy i w jözyku Java 1.1 zostaäo zastñpione przez kon- cepcjö obiektów odczytu i zapisu. Ze wzglödu na koniecznoĈè zachowania zgodnoĈci System.in, System.out i System.err wciñĔ sñ strumieniami, nie obiektami odczytu i zapisu. Ale obecna klasa PrintStream konwertuje znaki Unicode na schemat kodowa- nia lokalnego systemu w ten sam sposób, co klasa PrintWriter. Gdy uĔywamy metod print i println, obiekty PrintStream dziaäajñ tak samo jak obiekty PrintWriter, ale w przeciwieþstwie do PrintWriter pozwalajñ wysyäaè bajty za pomocñ metod write(int) i write(byte[]). java.io.PrintWriter 1.1 Q PrintWriter(Writer out) Q PrintWriter(Writer out, boolean autoFlush) tworzy nowy obiekt klasy PrintWriter. Parametry: out autoFlush obiekt zapisu tekstu. true oznacza, Īe metody println bĊdą opróĪniaü bufor (domyĞlnie: false). 30 Java. Techniki zaawansowane Q PrintWriter(OutputStream out) Q PrintWriter(OutputStream out, boolean autoFlush) tworzy nowy obiekt klasy PrintWriter na podstawie istniejącego obiektu typu OutputStream, poprzez utworzenie poĞredniczącego obiektu klasy OutputStreamWriter. Q PrintWriter(String filename) Q PrintWriter(File file) tworzy nowy obiekt klasy PrintWriter zapisujący dane do pliku poprzez utworzenie poĞredniczącego obiektu klasy FileWriter. Q void print(Object obj) drukuje áaĔcuch zwracany przez metodĊ toString danego obiektu. Parametry: drukowany obiekt. obj Q void print(String p) drukuje áaĔcuch Unicode. Q void println(String p) drukuje áaĔcuch zakoĔczony znakiem koĔca wiersza. JeĪeli automatyczne opróĪnianie jest wáączone, opróĪnia bufor strumienia. Q void print(char[] p) drukuje tablicĊ znaków Unicode. Q void print(char c) drukuje znak Unicode. Q void print(int i) Q void print(long l) Q void print(float f) Q void print(double d) Q void print(boolean b) drukuje podaną wartoĞü w formacie tekstowym. Q void printf(String format, Object... args) drukuje podane wartoĞci wedáug áaĔcucha formatującego. SpecyfikacjĊ áaĔcucha formatującego znajdziesz w rozdziale 3. ksiąĪki Java 2. Podstawy. Q boolean checkError() zwraca true, jeĪeli wystąpiá báąd formatowania lub zapisu. JeĪeli w strumieniu danych wystąpi báąd, strumieĔ zostanie uznany za niepewny (ang. tainted) i wszystkie nastĊpne wywoáania metody checkError bĊdą zwracaü true. RozdziaÄ 1. Q Strumienie i pliki 31 Wczytywanie tekstu Wiemy juĪ, Īe: Q aby zapisaü dane w formacie binarnym, uĪywamy klasy DataOutputStream; Q aby zapisaü dane w formacie tekstowym, uĪywamy klasy PrintWriter. Na tej podstawie moĪna siĊ domyĞlaü, Īe istnieje równieĪ klasa analogiczna do DataInput ´Stream, która pozwoli nam czytaü dane w formacie tekstowym. NajbliĪszym odpowiedni- kiem jest w tym przypadku klasa Scanner, którą wykorzystywaliĞmy intensywnie w ksiąĪce Java 2. Podstawy. Niestety, przed wprowadzeniem Java SE 5.0 moĪna byáo uĪyü w tym celu jedynie klasy BufferedReader. Ma ona metodĊ readLine pozwalającą pobraü wiersz tekstu. Aby ją wykorzystaü, musimy najpierw poáączyü obiekt typu BufferedReader ze Ĩródáem wejĞcia. BufferedReader in = new BufferedReader(new FileReader( employee.txt )); JeĪeli dalsze wczytywanie nie jest moĪliwe, metoda readLine zwraca null. Typowa pĊtla pobierania danych wygląda wiĊc nastĊpująco: String line; while ((line = in.readLine()) != null) { operacje na danych line } Jednak klasa BufferedReader nie udostĊpnia metod odczytu danych liczbowych. Dlatego do odczytu danych sugerujemy zastosowanie klasy Scanner. Zapis obiektów w formacie tekstowym W tym podrozdziale przeanalizujemy dziaáanie przykáadowego programu, który bĊdzie zapi- sywaü tablicĊ obiektów typu Employee w pliku tekstowym. Dane kaĪdego obiektu zostaną zapisane w osobnym wierszu. WartoĞci pól skáadowych zostaną oddzielone od siebie sepa- ratorami. Jako separatora uĪywamy pionowej kreski (|) (innym popularnym separatorem jest dwukropek (:), zabawa polega na tym, Īe kaĪdy programista uĪywa innego separatora). Naturalnie, taki wybór stawia przed nami pytanie, co bĊdzie, jeĞli znak | znajdzie siĊ w jednym z zapisywanych przez nas áaĔcuchów? Oto przykáadowy zbiór danych obiektów: Harry Hacker|35500|1989|10|1 Carl Cracker|75000|1987|12|15 Tony Tester|38000|1990|3|15 Zapis tych rekordów jest prosty. PoniewaĪ korzystamy z pliku tekstowego, uĪywamy klasy PrintWriter. Po prostu zapisujemy wszystkie pola skáadowe, za kaĪdym z nich stawiając |, albo teĪ, po ostatnim polu, . Operacje te wykona poniĪsza metoda writeData, którą dodamy do klasy Employee. 32 Java. Techniki zaawansowane public void write
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Java. Techniki zaawansowane. Wydanie VIII
Autor:
,

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: