Java Receptury.pdf

(345 KB) Pobierz
IDZ DO
PRZYK£ADOWY ROZDZIA£
SPIS TRE CI
Java. Receptury
Autor: Ian F. Darwin
T³umaczenie: Piotr Rajca
ISBN: 83-7197-902-9
Tytu³ orygina³u:
Java Cookbook
Format: B5, stron: 886
Przyk³ady na ftp: 1157 kB
KATALOG KSI¥¯EK
KATALOG ONLINE
ZAMÓW DRUKOWANY KATALOG
TWÓJ KOSZYK
DODAJ DO KOSZYKA
Ksi¹¿ka „Java. Receptury” zawiera kolekcjê rozwi¹zañ setek problemów, z którymi
programi ci u¿ywaj¹cy jêzyka Java spotykaj¹ siê bardzo czêsto. Receptury znajduj¹
zastosowanie w szerokim spektrum zagadnieñ: od ca³kiem prostych, takich jak
okre lanie 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¿liwo ci 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 d wiêku
• Tworzenie graficznego interfejsu u¿ytkownika
CENNIK I INFORMACJE
ZAMÓW INFORMACJE
O NOWO CIACH
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 treści
Wstęp................................................................................................................................ 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ąć konieczności stosowania
programów uruchomieniowych?..................................................................................... 60
1.14. Dekompilacja plików klasowych Javy ............................................................................. 63
1.15. Zapobieganie możliwości 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 wartości zmiennych środowiskowych............................................................. 71
4
Spis treści
2.2. Właściwości 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 łańcucha ................................................................................ 92
3.2. Dzielenie łańcuchów znaków za pomocą obiektu klasy StringTokenizer......................... 93
3.3. Łączenie łańcuchów znaków przy użyciu operatora + i klasy StringBuffer ..................... 96
3.4. Przetwarzanie łańcucha znaków po jednej literze............................................................. 97
3.5. Wyrównywanie łańcuchów znaków.................................................................................. 98
3.6. Konwersja pomiędzy znakami Unicode a łańcuchami znaków ...................................... 101
3.7. Odwracanie kolejności słów lub znaków w łańcuchu..................................................... 102
3.8. Rozwijanie i kompresja znaków tabulacji........................................................................ 104
3.9. Kontrola wielkości liter.................................................................................................... 108
3.10. Wcinanie zawartości dokumentów tekstowych ............................................................ 109
3.11. Wprowadzanie znaków niedrukowalnych .................................................................... 111
3.12. Usuwanie odstępów z końca łańcucha .......................................................................... 112
3.13. Przetwarzanie danych rozdzielonych przecinkami ....................................................... 113
3.14. Program — proste narzędzie 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żeń regularnych ........................................................................................ 128
4.2. Jak wyrażenia regularne działają w praktyce? ................................................................ 130
4.3. Wykorzystanie wyrażeń regularnych w języku Java ...................................................... 132
4.4. Interaktywne testowanie wyrażeń regularnych .............................................................. 134
4.5. Określanie tekstu pasującego do wzorca......................................................................... 135
4.6. Zastępowanie określonego tekstu ................................................................................... 136
4.7. Wyświetlanie wszystkich wystąpień wzorca .................................................................. 137
4.8. Wyświetlanie wierszy zawierających fragment pasujący do wzorca .............................. 139
4.9. Kontrola wielkości znaków w metodach match() i subst() ............................................. 141
4.10. Prekompilacja wyrażeń regularnych.............................................................................. 141
Spis treści
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 łańcuch znaków stanowi poprawną liczbę......................................... 154
5.2. Zapisywanie dużych wartości 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ładności liczb zmiennoprzecinkowych ............................ 158
5.5. Porównywanie liczb zmiennoprzecinkowych ................................................................. 160
5.6. Zaokrąglanie wartości zmiennoprzecinkowych .............................................................. 161
5.7. Formatowanie liczb ......................................................................................................... 162
5.8. Konwersje pomiędzy różnymi systemami liczbowymi
— dwójkowym, ósemkowym, dziesiętnym i szesnastkowym ....................................... 165
5.9. Operacje na grupie liczb całkowitych .............................................................................. 166
5.10. Posługiwanie się 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 wartościach ................................................................. 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. Określanie bieżącej daty .................................................................................................. 193
6.2. Wyświetlanie daty i czasu w zadanym formacie ............................................................ 194
6.3. Przedstawianie dat w innych systemach ......................................................................... 196
6.4. Konwersja liczb określających datę i czas na obiekt Calendar lub ilość sekund ............. 197
6.5. Analiza łańcuchó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 treści
6.8. Obliczanie różnic pomiędzy dwiema datami .................................................................. 202
6.9. Porównywanie dat........................................................................................................... 203
6.10. Określanie dnia tygodnia, miesiąca lub roku oraz numeru tygodnia ........................... 205
6.11. Wyświetlanie kalendarza ............................................................................................... 207
6.12. Czasomierze o dużej dokładności.................................................................................. 209
6.13. Wstrzymywanie wykonywania programu .................................................................... 211
6.14. Program — usługa przypominająca .............................................................................. 212
Rozdział 7.
Strukturalizacja danych w języku Java ...................................... 215
7.0. Wprowadzenie................................................................................................................. 215
7.1. Strukturalizacja danych przy użyciu tablic...................................................................... 216
7.2. Modyfikacja wielkości tablic............................................................................................ 218
7.3. Klasa podobna do tablicy, lecz bardziej dynamiczna ...................................................... 219
7.4. Iteratory — dostęp 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 łańcuchów znaków w obiektach Properties i Preferences ......................... 226
7.8. Sortowanie kolekcji.......................................................................................................... 230
7.9. Sortowanie w języku Java 1.1 .......................................................................................... 234
7.10. Unikanie konieczności sortowania danych .................................................................... 235
7.11. Zbiory ............................................................................................................................ 237
7.12. Odnajdywanie obiektu w kolekcji ................................................................................. 238
7.13. Zamiana kolekcji na tablicę............................................................................................ 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 szybkości działania ................................................................ 246
Rozdział 8.
Techniki obiektowe ....................................................................... 251
8.0. Wprowadzenie................................................................................................................. 251
8.1. Wyświetlanie 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 wewnętrznych ................................................................................. 263
8.7. Tworzenie metod zwrotnych przy wykorzystaniu interfejsów....................................... 264

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin