Java. Receptury, fragmenty-ksiazek-heliona
[ Pobierz całość w formacie PDF ]
IDZ DO
PRZYK£ADOW
Java. Receptury
SPIS TRECI
KATALOG KSI¥¯EK
Autor: Ian F. Darwin
T³umaczenie: Piotr Rajca
ISBN: 83-7197-902-9
Tytu³ orygina³
Format: B5, stron: 886
KATALOG ONLINE
ZAMÓW DRUKOWANY KATALOG
TWÓJ KOSZYK
Ksi¹¿ka „Java. Receptury” zawiera kolekcjê rozwi¹zañ setek problemów, z którymi
programici u¿ywaj¹cy jêzyka Java spotykaj¹ siê bardzo czêsto. Receptury znajduj¹
zastosowanie w szerokim spektrum zagadnieñ: od ca³kiem prostych, takich jak
okrelanie zmiennej rodowiskowej CLASSPATH, a¿ do ca³kiem z³o¿onych programów
pokazuj¹cych jak obs³ugiwaæ dokumenty XML lub wzbogaciæ sw¹ aplikacjê
o mechanizmy obs³ugi poczty elektronicznej.
Niezale¿nie od tego, jak planujesz wykorzystaæ tê ksi¹¿kê — czy jako ród³o pomys³ów
i inspiracji, czy te¿ jako sposób poszerzenia swej wiedzy o jêzyku Java — zawsze bêdzie
ona stanowiæ wa¿n¹ czêæ Twojej biblioteki. Ma³o która ksi¹¿ka prezentuje tak wiele
mo¿liwoci Javy oraz nauczy Ciê praktycznego wykorzystania omawianych zagadnieñ.
W ksi¹¿ce zosta³y omówione nastêpuj¹ce zagadnienia:
• Kompilacja, uruchamianie oraz testowanie programów napisanych w Javie
• Interakcja ze rodowiskiem
• £añcuchy znaków oraz dopasowywanie wzorców
• Tablice oraz inne kolekcje danych
• Programowa obs³uga portów szeregowych i równoleg³ych
• Pliki, katalogi i system plików
• Tworzenie programów sieciowych pe³ni¹cych funkcje klientów oraz serwerów
• Aplikacje internetowe, w tym tak¿e aplety
• Serwlety oraz dokumenty JSP
• Poczta elektroniczna
• Obs³uga baz danych
• Wykorzystanie XML
• Programowanie rozproszone
• Introspekcja
• Tworzenie programów wielojêzycznych
• Wykorzystanie grafiki oraz dwiêku
• Tworzenie graficznego interfejsu u¿ytkownika
DODAJ DO KOSZYKA
CENNIK I INFORMACJE
ZAMÓW INFORMACJE
O NOWOCIACH
ZAMÓW CENNIK
CZYTELNIA
FRAGMENTY KSI¥¯EK ONLINE
Wydawnictwo Helion
ul. Chopina 6
44-100 Gliwice
tel. (32)230-98-63
e-mail: helion@helion.pl
Spis treci
Wstp................................................................................................................................ 15
Rozdział 1. Rozpoczynanie pracy: kompilacja, uruchamianie i testowanie...31
1.0. Wprowadzenie...................................................................................................................31
1.1. Kompilacja i uruchamianie programów napisanych w Javie — JDK................................32
1.2. Edycja i kompilacja programów przy u#yciu edytorów wyposa#onych
w kolorowanie syntaktyczne.............................................................................................37
1.3. Kompilacja, uruchamianie i testowanie programów przy u#yciu IDE .............................39
1.4. Wykorzystanie klas przedstawionych w niniejszej ksi*#ce...............................................44
1.5. Automatyzacja kompilacji przy wykorzystaniu skryptu jr ...............................................45
1.6. Automatyzacja procesu kompilacji przy u#yciu programu make.....................................46
1.7. Automatyzacja kompilacji przy u#yciu programu Ant.....................................................48
1.8. Uruchamianie apletów ...................................................................................................... 51
1.9. Komunikaty o odrzuconych metodach .............................................................................53
1.10. Testowanie warunkowe bez u#ycia dyrektywy #ifdef ....................................................55
1.11. Komunikaty testowe........................................................................................................57
1.12. Wykorzystanie programu uruchomieniowego................................................................58
1.13. Testowanie jednostkowe — jak unikn*4 konieczno5ci stosowania
programów uruchomieniowych?.....................................................................................60
1.14. Dekompilacja plików klasowych Javy.............................................................................63
1.15. Zapobieganie mo#liwo5ci dekompilacji plików klasowych Javy.....................................65
1.16. Uzyskiwanie czytelnych komunikatów o wyj*tkach.......................................................66
1.17. Poszukiwanie przykładowych kodów :ródłowych.........................................................68
1.18. Program Debug................................................................................................................70
Rozdział 2. Interakcja ze rodowiskiem............................................................ 71
2.0. Wprowadzenie...................................................................................................................71
2.1. Pobieranie warto5ci zmiennych 5rodowiskowych.............................................................71
4
Spis treci
2.2. Wła5ciwo5ci systemowe ....................................................................................................73
2.3. Tworzenie kodu zale#nego od u#ywanej wersji JDK........................................................75
2.4. Tworzenie kodu zale#nego od u#ywanego systemu operacyjnego ..................................77
2.5. Efektywne wykorzystanie zmiennej CLASSPATH ...........................................................79
2.6. Stosowanie rozszerzaj*cych interfejsów programistycznych lub API
zapisanych w plikach JAR.................................................................................................82
2.7. Analiza argumentów podanych w wierszu wywołania programu...................................83
Rozdział 3. Ła#cuchy znaków i przetwarzanie tekstów..................................89
3.0. Wprowadzenie...................................................................................................................89
3.1. Odczytywanie fragmentów łaAcucha ................................................................................92
3.2. Dzielenie łaAcuchów znaków za pomoc* obiektu klasy StringTokenizer.........................93
3.3. Ł*czenie łaAcuchów znaków przy u#yciu operatora + i klasy StringBuffer .....................96
3.4. Przetwarzanie łaAcucha znaków po jednej literze.............................................................97
3.5. Wyrównywanie łaAcuchów znaków..................................................................................98
3.6. Konwersja pomiEdzy znakami Unicode a łaAcuchami znaków ...................................... 101
3.7. Odwracanie kolejno5ci słów lub znaków w łaAcuchu..................................................... 102
3.8. Rozwijanie i kompresja znaków tabulacji........................................................................ 104
3.9. Kontrola wielko5ci liter.................................................................................................... 108
3.10. Wcinanie zawarto5ci dokumentów tekstowych ............................................................ 109
3.11. Wprowadzanie znaków niedrukowalnych.................................................................... 111
3.12. Usuwanie odstEpów z koAca łaAcucha .......................................................................... 112
3.13. Przetwarzanie danych rozdzielonych przecinkami....................................................... 113
3.14. Program — proste narzEdzie do formatowania tekstów............................................... 118
3.15. Program — fonetyczne porównywanie nazwisk........................................................... 120
Rozdział 4. Dopasowywanie wzorców i wyra(enia regularne...................... 125
4.0. Wprowadzenie................................................................................................................. 125
4.1. Składnia wyra#eA regularnych........................................................................................ 128
4.2. Jak wyra#enia regularne działaj* w praktyce? ................................................................ 130
4.3. Wykorzystanie wyra#eA regularnych w jEzyku Java ...................................................... 132
4.4. Interaktywne testowanie wyra#eA regularnych .............................................................. 134
4.5. Okre5lanie tekstu pasuj*cego do wzorca......................................................................... 135
4.6. ZastEpowanie okre5lonego tekstu ................................................................................... 136
4.7. Wy5wietlanie wszystkich wyst*pieA wzorca .................................................................. 137
4.8. Wy5wietlanie wierszy zawieraj*cych fragment pasuj*cy do wzorca.............................. 139
4.9. Kontrola wielko5ci znaków w metodach match() i subst() ............................................. 141
4.10. Prekompilacja wyra#eA regularnych.............................................................................. 141
Spis treci
5
4.11. Odnajdywanie znaków nowego wiersza....................................................................... 143
4.12. Program — analizowanie danych.................................................................................. 144
4.13. Program — pełna wersja programu grep...................................................................... 146
Rozdział 5. Liczby............................................................................................. 151
5.0. Wprowadzenie................................................................................................................. 151
5.1. Sprawdzanie, czy łaAcuch znaków stanowi poprawn* liczbE......................................... 154
5.2. Zapisywanie du#ych warto5ci w zmiennych „mniejszych” typów................................. 155
5.3. Pobieranie ułamka z liczby całkowitej bez konwertowania go
do postaci zmiennoprzecinkowej.................................................................................... 156
5.4. Wymuszanie zachowania dokładno5ci liczb zmiennoprzecinkowych............................ 158
5.5. Porównywanie liczb zmiennoprzecinkowych................................................................. 160
5.6. Zaokr*glanie warto5ci zmiennoprzecinkowych.............................................................. 161
5.7. Formatowanie liczb ......................................................................................................... 162
5.8. Konwersje pomiEdzy ró#nymi systemami liczbowymi
— dwójkowym, ósemkowym, dziesiEtnym i szesnastkowym ....................................... 165
5.9. Operacje na grupie liczb całkowitych.............................................................................. 166
5.10. Posługiwanie siE cyframi rzymskimi............................................................................. 167
5.11. Formatowanie z zachowaniem odpowiedniej postaci liczby mnogiej........................... 172
5.12. Generowanie liczb losowych ......................................................................................... 173
5.13. Generowanie lepszych liczb losowych .......................................................................... 174
5.14. Obliczanie funkcji trygonometrycznych ........................................................................ 176
5.15. Obliczanie logarytmów.................................................................................................. 176
5.16. Mno#enie macierzy........................................................................................................ 177
5.17. Operacje na liczbach zespolonych.................................................................................. 179
5.18. Obsługa liczb o bardzo du#ych warto5ciach ................................................................. 181
5.19. Program TempConverter............................................................................................... 183
5.20. Program — generowanie liczbowych palindromów ..................................................... 186
Rozdział 6. Daty i godziny............................................................................... 191
6.0. Wprowadzenie................................................................................................................. 191
6.1. Okre5lanie bie#*cej daty.................................................................................................. 193
6.2. Wy5wietlanie daty i czasu w zadanym formacie ............................................................ 194
6.3. Przedstawianie dat w innych systemach......................................................................... 196
6.4. Konwersja liczb okre5laj*cych datE i czas na obiekt Calendar lub ilo54 sekund............. 197
6.5. Analiza łaAcuchów znaków i ich zamiana na daty.......................................................... 198
6.6. Konwersja dat wyra#onych w formie sekund na obiekt Date......................................... 200
6.7. Dodawanie i odejmowanie dat przy wykorzystaniu klas Date oraz Calendar............... 201
6
Spis treci
6.8. Obliczanie ró#nic pomiEdzy dwiema datami.................................................................. 202
6.9. Porównywanie dat...........................................................................................................203
6.10. Okre5lanie dnia tygodnia, miesi*ca lub roku oraz numeru tygodnia ........................... 205
6.11. Wy5wietlanie kalendarza............................................................................................... 207
6.12. Czasomierze o du#ej dokładno5ci.................................................................................. 209
6.13. Wstrzymywanie wykonywania programu .................................................................... 211
6.14. Program — usługa przypominaj*ca .............................................................................. 212
Rozdział 7. Strukturalizacja danych w jzyku Java ...................................... 215
7.0. Wprowadzenie................................................................................................................. 215
7.1. Strukturalizacja danych przy u#yciu tablic...................................................................... 216
7.2. Modyfikacja wielko5ci tablic............................................................................................ 218
7.3. Klasa podobna do tablicy, lecz bardziej dynamiczna...................................................... 219
7.4. Iteratory — dostEp do danych w sposób niezale#ny od ich typów ................................ 221
7.5. Strukturalizacja danych przy wykorzystaniu list poł*czonych....................................... 223
7.6. Odwzorowywanie przy wykorzystaniu klas Hashtable oraz HashMap ........................ 225
7.7. Zapisywanie łaAcuchów znaków w obiektach Properties i Preferences ......................... 226
7.8. Sortowanie kolekcji.......................................................................................................... 230
7.9. Sortowanie w jEzyku Java 1.1.......................................................................................... 234
7.10. Unikanie konieczno5ci sortowania danych.................................................................... 235
7.11. Zbiory ............................................................................................................................ 237
7.12. Odnajdywanie obiektu w kolekcji ................................................................................. 238
7.13. Zamiana kolekcji na tablicE............................................................................................ 240
7.14. Tworzenie własnego iteratora........................................................................................ 241
7.15. Stos................................................................................................................................. 243
7.16. Struktury wielowymiarowe........................................................................................... 244
7.17. Kolekcje.......................................................................................................................... 246
7.18. Program — porównanie szybko5ci działania ................................................................ 246
Rozdział 8. Techniki obiektowe....................................................................... 251
8.0. Wprowadzenie................................................................................................................. 251
8.1. Wy5wietlanie obiektów — formatowanie obiektów przy u#yciu metody toString() ...... 253
8.2. Przesłanianie metody equals ........................................................................................... 255
8.3. Przesłanianie metody hashCode...................................................................................... 257
8.4. Metoda clone ................................................................................................................... 259
8.5. Metoda finalize ................................................................................................................ 261
8.6. Wykorzystanie klas wewnEtrznych................................................................................. 263
8.7. Tworzenie metod zwrotnych przy wykorzystaniu interfejsów....................................... 264
[ Pobierz całość w formacie PDF ]