Wprowadzenie do Javy. Programowanie i struktury danych - ebook

Mijają lata, dorastają kolejne pokolenia programistów, a Java wciąż zachwyca swoimi możliwościami. Jest językiem równocześnie nowoczesnym, dojrzałym i... eleganckim. Twórcy Javy od jej pierwszego wydania starali się wdrażać awangardowe rozwiązania, pamiętając równocześnie o niezawodności i bezpieczeństwie kodu. Java wciąż pozostaje ulubionym narzędziem profesjonalistów tworzących aplikacje internetowe. Przy czym jej możliwości są o wiele większe. Aby jednak w przyszłości osiągać sukcesy jako programista Javy, trzeba gruntownie opanować podstawy tego języka i swobodnie operować instrukcjami sterującymi, pętlami, metodami i tablicami.

To dwunaste, rozszerzone wydanie znakomitego podręcznika do nauki Javy, w pełni przejrzane, poprawione i zaktualizowane (uwzględnia nowości wprowadzone w Javie SE 9, 10 i 11). Ułatwia zdobycie solidnych podstaw języka i płynne przejście do tworzenia programów służących do rozwiązywania konkretnych problemów z takich dziedzin jak matematyka, ekonomia, finanse, tworzenie gier i animacji. W książce precyzyjnie wyjaśniono zasady korzystania z różnych struktur danych i tworzenia algorytmów. Zamieszczono również wskazówki dotyczące ich implementacji i wydajności. Zrozumienie prezentowanych treści jest łatwiejsze dzięki licznym przykładom i ćwiczeniom do samodzielnego wykonania. Znakomitym uzupełnieniem materiału są także uwagi, ostrzeżenia i wskazówki programistyczne, zawierające cenne porady i przemyślenia.

W książce między innymi:

• solidne podstawy Javy
• programowanie zorientowane obiektowo
• projektowanie interfejsów użytkownika
• struktury danych i algorytmy
• wielowątkowość i programowanie równoległe

Zostań profesjonalnym programistą Javy!

Przedmowa (19)

Rozdział 1. Wprowadzenie do komputerów, programów i Javy (27)

• 1.1. Wprowadzenie (28)
• 1.2. Czym jest komputer? (28)
• 1.3. Języki programowania (33)
• 1.4. Systemy operacyjne (36)
• 1.5. Java, sieć WWW i inne zagadnienia (37)
• 1.6. Specyfikacja Javy, API, JDK, JRE i IDE (38)
• 1.7. Prosty program w Javie (39)
• 1.8. Tworzenie, kompilowanie i wykonywanie programu w Javie (42)
• 1.9. Styl programowania i dokumentacja (46)
• 1.10. Błędy w programach (47)
• 1.11. Tworzenie programów za pomocą środowiska NetBeans (51)
• 1.12. Tworzenie programów w Javie z użyciem środowiska Eclipse (54)

Rozdział 2. Podstawy programowania (61)

• 2.1. Wprowadzenie (62)
• 2.2. Pisanie prostego programu (62)
• 2.3. Wczytywanie danych wejściowych z konsoli (65)
• 2.4. Identyfikatory (68)
• 2.5. Zmienne (69)
• 2.6. Instrukcje przypisania i wyrażenia przypisania (70)
• 2.7. Stałe nazwane (72)
• 2.8. Konwencje nazewnicze (73)
• 2.9. Liczbowe typy danych i operacje na nich (73)
• 2.10. Literały liczbowe (78)
• 2.11. Narzędzie JShell (79)
• 2.12. Obliczanie wyrażeń i priorytety operatorów (82)
• 2.13. Studium przypadku: wyświetlanie aktualnego czasu (83)
• 2.14. Złożone operatory przypisania (85)
• 2.15. Operatory inkrementacji i dekrementacji (86)
• 2.16. Konwersje typów liczbowych (88)
• 2.17. Proces rozwoju oprogramowania (91)
• 2.18. Studium przypadku: przeliczanie kwot pieniędzy na mniejsze nominały (95)
• 2.19. Często występujące błędy i pułapki (97)

Rozdział 3. Instrukcje sterujące (109)

• 3.1. Wprowadzenie (110)
• 3.2. Typ danych boolean oraz wartości i wyrażenia logiczne (110)
• 3.3. Instrukcje if (112)
• 3.4. Instrukcje if-else z dwiema ścieżkami (115)
• 3.5. Zagnieżdżone instrukcje if i instrukcje if-else z wieloma ścieżkami (116)
• 3.6. Typowe błędy i pułapki (118)
• 3.7. Generowanie liczb losowych (122)
• 3.8. Studium przypadku: obliczanie wskaźnika BMI (124)
• 3.9. Studium przypadku: obliczanie podatków (126)
• 3.10. Operatory logiczne (129)
• 3.11. Studium przypadku: wykrywanie roku przestępnego (133)
• 3.12. Studium przypadku: loteria (134)
• 3.13. Instrukcje switch (136)
• 3.14. Operatory warunkowe (140)
• 3.15. Priorytety i łączność operatorów (141)
• 3.16. Debugowanie (142)

Rozdział 4. Funkcje matematyczne, znaki i łańcuchy znaków (157)

• 4.1. Wprowadzenie (158)
• 4.2. Standardowe funkcje matematyczne (158)
• 4.3. Typ danych char i jego operacje (163)
• 4.4. Typ String (169)
• 4.5. Studia przypadku (178)
• 4.6. Formatowanie danych wyjściowych w konsoli (185)

Rozdział 5. Pętle (199)

• 5.1. Wprowadzenie (200)
• 5.2. Pętla while (200)
• 5.3. Studium przypadku: zgadywanie liczb (203)
• 5.4. Strategie projektowania pętli (206)
• 5.5. Sterowanie pętlą na podstawie potwierdzenia od użytkownika lub wartości wartownika (209)
• 5.6. Pętla do-while (212)
• 5.7. Pętla for (214)
• 5.8. Której pętli użyć? (218)
• 5.9. Pętle zagnieżdżone (220)
• 5.10. Minimalizowanie błędów numerycznych (222)
• 5.11. Studia przypadków (224)
• 5.12. Słowa kluczowe break i continue (229)
• 5.13. Studium przypadku: wykrywanie palindromów (232)
• 5.14. Studium przypadku: wyświetlanie liczb pierwszych (234)

Rozdział 6. Metody (249)

• 6.1. Wprowadzenie (250)
• 6.2. Definiowanie metody (251)
• 6.3. Wywoływanie metody (252)
• 6.4. Metody void i metody zwracające wartość (255)
• 6.5. Przekazywanie argumentów przez wartość (258)
• 6.6. Pisanie modułowego kodu (262)
• 6.7. Studium przypadku: przekształcanie liczb szesnastkowych na dziesiętne (264)
• 6.8. Przeciążanie metod (266)
• 6.9. Zasięg zmiennych (269)
• 6.10. Studium przypadku: generowanie losowych znaków (271)
• 6.11. Abstrakcja w postaci metody i stopniowe uszczegóławianie kodu (273)

Rozdział 7. Tablice jednowymiarowe (295)

• 7.1. Wprowadzenie (296)
• 7.2. Podstawowe informacje o tablicach (296)
• 7.3. Studium przypadku: analizowanie liczb (303)
• 7.4. Studium przypadku: talia kart (304)
• 7.5. Kopiowanie tablic (306)
• 7.6. Przekazywanie tablic do metod (308)
• 7.7. Zwracanie tablicy przez metodę (311)
• 7.8. Studium przypadku: zliczanie wystąpień każdej litery (312)
• 7.9. Listy argumentów o zmiennej długości (315)
• 7.10. Wyszukiwanie w tablicach (316)
• 7.11. Sortowanie tablic (320)
• 7.12. Klasa Arrays (322)
• 7.13. Argumenty wiersza poleceń (324)

Rozdział 8. Tablice wielowymiarowe (339)

• 8.1. Wprowadzenie (340)
• 8.2. Podstawy tablic dwuwymiarowych (340)
• 8.3. Przetwarzanie tablic dwuwymiarowych (343)
• 8.4. Przekazywanie tablic dwuwymiarowych do metod (345)
• 8.5. Studium przypadku: ocena testu wielokrotnego wyboru (347)
• 8.6. Studium przypadku: znajdowanie pary najbliższych punktów (349)
• 8.7. Studium przypadku: sudoku (351)
• 8.8. Tablice wielowymiarowe (354)

Rozdział 9. Obiekty i klasy (375)

• 9.1. Wprowadzenie (376)
• 9.2. Definiowanie klas służących do tworzenia obiektów (376)
• 9.3. Przykład: definiowanie klas i tworzenie obiektów (378)
• 9.4. Tworzenie obiektów z użyciem konstruktorów (383)
• 9.5. Używanie obiektów za pomocą zmiennych referencyjnych (385)
• 9.6. Używanie klas z biblioteki Javy (389)
• 9.7. Zmienne, stałe i metody statyczne (392)
• 9.8. Modyfikatory widoczności (398)
• 9.9. Hermetyzacja pól (400)
• 9.10. Przekazywanie obiektów do metod (402)
• 9.11. Tablica obiektów (407)
• 9.12. Niemodyfikowalne obiekty i klasy (409)
• 9.13. Zasięg zmiennych (411)
• 9.14. Referencja this (412)

Rozdział 10. Myślenie obiektowe (421)

• 10.1. Wprowadzenie (422)
• 10.2. Abstrakcja w postaci klasy i hermetyzacja (422)
• 10.3. Myślenie w sposób obiektowy (426)
• 10.4. Relacje między klasami (429)
• 10.5. Studium przypadku: projektowanie klasy Course (432)
• 10.6. Studium przypadku: projektowanie klasy reprezentującej stos (434)
• 10.7. Przetwarzanie wartości typów podstawowych jako obiektów (437)
• 10.8. Automatyczna konwersja między typami podstawowymi a typami nakładkowymi (441)
• 10.9. Klasy BigInteger i BigDecimal (442)
• 10.10. Klasa String (443)
• 10.11. Klasy StringBuilder i StringBuffer (451)

Rozdział 11. Dziedziczenie i polimorfizm (467)

• 11.1. Wprowadzenie (468)
• 11.2. Nadklasy i podklasy (468)
• 11.3. Używanie słowa kluczowego super (474)
• 11.4. Przesłanianie metod (478)
• 11.5. Przesłanianie a przeciążanie (478)
• 11.6. Klasa Object i metoda toString() (480)
• 11.7. Polimorfizm (481)
• 11.8. Wiązanie dynamiczne (482)
• 11.9. Rzutowanie obiektów i operator instanceof (486)
• 11.10. Metoda equals z klasy Object (490)
• 11.11. Klasa ArrayList (491)
• 11.12. Przydatne metody dotyczące list (497)
• 11.13. Studium przypadku: niestandardowa klasa reprezentująca stos (498)
• 11.14. Dane i metody z modyfikatorem protected (500)
• 11.15. Zapobieganie rozszerzaniu klas i przesłanianiu metod (502)

Rozdział 12. Obsługa wyjątków i tekstowe operacje wejścia - wyjścia (511)

• 12.1. Wprowadzenie (512)
• 12.2. Omówienie obsługi wyjątków (512)
• 12.3. Typy wyjątków (518)
• 12.4. Deklarowanie, zgłaszanie i przechwytywanie wyjątków (520)
• 12.5. Klauzula finally (529)
• 12.6. Kiedy stosować wyjątki? (531)
• 12.7. Ponowne zgłaszanie wyjątków (532)
• 12.8. Łańcuch wyjątków (532)
• 12.9. Definiowanie niestandardowych klas wyjątków (533)
• 12.10. Klasa File (537)
• 12.11. Plikowe operacje wejścia - wyjścia (539)
• 12.12. Wczytywanie danych z internetu (547)
• 12.13. Studium przypadku: robot internetowy (549)

Rozdział 13. Klasy abstrakcyjne i interfejsy (559)

• 13.1. Wprowadzenie (560)
• 13.2. Klasy abstrakcyjne (560)
• 13.3. Studium przypadku: klasa abstrakcyjna Number (565)
• 13.4. Studium przypadku: Calendar i GregorianCalendar (568)
• 13.5. Interfejsy (570)
• 13.6. Interfejs Comparable (575)
• 13.7. Interfejs Cloneable (579)
• 13.8. Interfejsy a klasy abstrakcyjne (584)
• 13.9. Studium przypadku: klasa Rational (588)
• 13.10. Wskazówki dotyczące projektowania klas (594)

Rozdział 14. Podstawy platformy JavaFX (603)

• 14.1. Wprowadzenie (604)
• 14.2. JavaFX a Swing i AWT (604)
• 14.3. Podstawowa struktura programu używającego JavaFX (604)
• 14.4. Panele, grupy, kontrolki interfejsu użytkownika i kształty (607)
• 14.5. Wiązanie właściwości (611)
• 14.6. Wspólne właściwości i metody węzłów (614)
• 14.7. Klasa Color (616)
• 14.8. Klasa Font (617)
• 14.9. Klasy Image i ImageView (619)
• 14.10. Panele i grupy (622)
• 14.11. Kształty (631)
• 14.12. Studium przypadku: klasa ClockPane (645)

Rozdział 15. Programowanie sterowane zdarzeniami i animacje (659)

• 15.1. Wprowadzenie (660)
• 15.2. Zdarzenia i źródła zdarzeń (662)
• 15.3. Rejestrowanie obiektów obsługi zdarzeń i obsługa zdarzeń (664)
• 15.4. Klasy wewnętrzne (668)
• 15.5. Anonimowe wewnętrzne klasy obsługi zdarzeń (669)
• 15.6. Upraszczanie obsługi zdarzeń z użyciem wyrażeń lambda (672)
• 15.7. Studium przypadku: kalkulator kredytowy (677)
• 15.8. Zdarzenia związane z myszą (679)
• 15.9. Zdarzenia związane z klawiszami (680)
• 15.10. Odbiorniki dla obiektów obserwowalnych (684)
• 15.11. Animacje (687)
• 15.12. Studium przypadku: odbijająca się kulka (695)
• 15.13. Studium przypadku: mapa Stanów Zjednoczonych (699)

Rozdział 16. Kontrolki i multimedia JavaFX (713)

• 16.1. Wprowadzenie (714)
• 16.2. Labeled i Label (714)
• 16.3. Button (717)
• 16.4. CheckBox (719)
• 16.5. RadioButton (722)
• 16.6. TextField (725)
• 16.7. TextArea (727)
• 16.8. ComboBox (730)
• 16.9. ListView (733)
• 16.10. ScrollBar (737)
• 16.11. Slider (740)
• 16.12. Studium przypadku: tworzenie gry w kółko i krzyżyk (743)
• 16.13. Wideo i dźwięk (748)
• 16.14. Studium przypadku: flagi i hymny narodowe (752)

Rozdział 17. Binarne operacje wejścia - wyjścia (765)

• 17.1. Wprowadzenie (766)
• 17.2. Jak tekstowe operacje wejścia - wyjścia są obsługiwane w Javie? (766)
• 17.3. Tekstowe a binarne operacje I/O (767)
• 17.4. Klasy binarnych operacji I/O (768)
• 17.5. Studium przypadku: kopiowanie plików (779)
• 17.6. Zapis i odczyt obiektów (781)
• 17.7. Pliki o dostępie swobodnym (786)

Rozdział 18. Rekurencja (795)

• 18.1. Wprowadzenie (796)
• 18.2. Studium przypadku: obliczanie silni (796)
• 18.3. Studium przypadku: obliczanie liczb Fibonacciego (800)
• 18.4. Rozwiązywanie problemów z użyciem rekurencji (803)
• 18.5. Rekurencyjne metody pomocnicze (804)
• 18.6. Studium przypadku: obliczanie wielkości katalogu (807)
• 18.7. Studium przypadku: wieże Hanoi (809)
• 18.8. Studium przypadku: fraktale (813)
• 18.9. Rozwiązania rekurencyjne i iteracyjne (816)
• 18.10. Rekurencja ogonowa (817)

Rozdział 19. Typy generyczne (829)

• 19.1. Wprowadzenie (830)
• 19.2. Powody i zalety stosowania typów generycznych (830)
• 19.3. Definiowanie klas i interfejsów generycznych (833)
• 19.4. Metody generyczne (834)
• 19.5. Studium przypadku: sortowanie tablicy obiektów (836)
• 19.6. Typy surowe i zgodność wstecz (838)
• 19.7. Typy generyczne z wyrażeniami wieloznacznymi (840)
• 19.8. Wymazywanie typów i zastrzeżenia dotyczące typów generycznych (842)
• 19.9. Studium przypadku: generyczna klasa reprezentująca macierze (845)

Rozdział 20. Listy, stosy, kolejki i kolejki priorytetowe (853)

• 20.1. Wprowadzenie (854)
• 20.2. Kolekcje (854)
• 20.3. Iteratory (858)
• 20.4. Używanie metody forEach (860)
• 20.5. Listy (861)
• 20.6. Interfejs Comparator (866)
• 20.7. Statyczne metody list i kolekcji (871)
• 20.8. Studium przypadku: odbijające się kulki (874)
• 20.9. Klasy Vector i Stack (878)
• 20.10. Kolejki i kolejki priorytetowe (880)
• 20.11. Studium przypadku: przetwarzanie wyrażeń (883)

Rozdział 21. Zbiory i odwzorowania (895)

• 21.1. Wprowadzenie (896)
• 21.2. Zbiory (896)
• 21.3. Porównywanie wydajności zbiorów i list (905)
• 21.4. Studium przypadku: zliczanie słów kluczowych (907)
• 21.5. Odwzorowania (909)
• 21.6. Studium przypadku: wystąpienia słów (914)
• 21.7. Jednoelementowe i niemodyfikowalne kolekcje i odwzorowania (916)

Rozdział 22. Pisanie wydajnych algorytmów (921)

• 22.1. Wprowadzenie (922)
• 22.2. Pomiar wydajności algorytmów za pomocą notacji dużego O (922)
• 22.3. Przykłady: wyznaczanie dużego O (924)
• 22.4. Analizowanie złożoności czasowej algorytmów (928)
• 22.5. Wyznaczanie liczb Fibonacciego z wykorzystaniem programowania dynamicznego (931)
• 22.6. Znajdowanie największych wspólnych dzielników za pomocą algorytmu Euklidesa (934)
• 22.7. Wydajne algorytmy do znajdowania liczb pierwszych (938)
• 22.8. Znajdowanie pary najbliższych punktów metodą dziel i rządź (945)
• 22.9. Rozwiązywanie problemu ośmiu hetmanów za pomocą algorytmu z nawrotami (948)
• 22.10. Geometria obliczeniowa: znajdowanie otoczki wypukłej (951)
• 22.11. Dopasowywanie łańcuchów znaków (954)

Rozdział 23. Sortowanie (973)

• 23.1. Wprowadzenie (974)
• 23.2. Sortowanie przez wstawianie (974)
• 23.3. Sortowanie bąbelkowe (977)
• 23.4. Sortowanie przez scalanie (979)
• 23.5. Sortowanie szybkie (983)
• 23.6. Sortowanie przez kopcowanie (987)
• 23.7. Sortowanie kubełkowe i pozycyjne (996)
• 23.8. Sortowanie zewnętrzne (997)

Rozdział 24. Implementowanie list, stosów, kolejek i kolejek priorytetowych (1011)

• 24.1. Wprowadzenie (1012)
• 24.2. Standardowe operacje na listach (1012)
• 24.3. Listy tablicowe (1016)
• 24.4. Listy powiązane (1023)
• 24.5. Stosy i kolejki (1038)
• 24.6. Kolejki priorytetowe (1042)

Rozdział 25. Binarne drzewa poszukiwań (1049)

• 25.1. Wprowadzenie (1050)
• 25.2. Podstawy binarnych drzew poszukiwań (1050)
• 25.3. Reprezentowanie drzew BST (1051)
• 25.4. Wyszukiwanie elementu (1052)
• 25.5. Wstawianie elementu do drzewa BST (1052)
• 25.6. Przechodzenie drzewa (1054)
• 25.7. Klasa BST (1055)
• 25.8. Usuwanie elementów z drzewa BST (1065)
• 25.9. Wizualizowanie drzew i architektura MVC (1071)
• 25.10. Iteratory (1075)
• 25.11. Studium przypadku: kompresja danych (1077)

Rozdział 26. Drzewa AVL (1087)

• 26.1. Wprowadzenie (1088)
• 26.2. Wyważanie drzew (1088)
• 26.3. Projektowanie klas dla drzew AVL (1091)
• 26.4. Przesłanianie metody insert (1092)
• 26.5. Implementowanie rotacji (1094)
• 26.6. Implementowanie metody delete (1094)
• 26.7. Klasa AVLTree (1095)
• 26.8. Testowanie klasy AVLTree (1101)
• 26.9. Analiza złożoności czasowej operacji w drzewach AVL (1104)

Rozdział 27. Haszowanie (1109)

• 27.1. Wprowadzenie (1110)
• 27.2. Czym jest haszowanie? (1110)
• 27.3. Funkcje haszujące i skróty (1111)
• 27.4. Zarządzanie kolizjami z użyciem otwartego adresowania (1113)
• 27.5. Zarządzanie kolizjami metodą łańcuchową (1117)
• 27.6. Współczynnik wypełnienia i ponowne haszowanie (1118)
• 27.7. Implementowanie odwzorowania z użyciem haszowania (1120)
• 27.8. Implementowanie zbioru z użyciem haszowania (1130)

Rozdział 28. Grafy i ich zastosowania (1141)

• 28.1. Wprowadzenie (1142)
• 28.2. Podstawowa terminologia z obszaru grafów (1143)
• 28.3. Reprezentowanie grafów (1144)
• 28.4. Modelowanie grafów (1151)
• 28.5. Wizualizowanie grafów (1161)
• 28.6. Przechodzenie grafu (1165)
• 28.7. Przeszukiwanie w głąb (1166)
• 28.8. Studium przypadku: problem połączonych kół (1170)
• 28.9. Przeszukiwanie wszerz (1173)
• 28.10. Studium przypadku: problem dziewięciu monet (1176)

Rozdział 29. Grafy ważone i ich zastosowania (1189)

• 29.1. Wprowadzenie (1190)
• 29.2. Reprezentowanie grafów ważonych (1191)
• 29.3. Klasa WeightedGraph (1193)
• 29.4. Minimalne drzewa rozpinające (1201)
• 29.5. Znajdowanie najkrótszych ścieżek (1209)
• 29.6. Studium przypadku: problem dziewięciu monet z wagami (1217)

Rozdział 30. Operacje agregujące dla strumieni do przetwarzania kolekcji (1229)

• 30.1. Wprowadzenie (1230)
• 30.2. Potoki (1230)
• 30.3. IntStream, LongStream i DoubleStream (1237)
• 30.4. Równoległe strumienie (1239)
• 30.5. Redukcja strumienia z użyciem metody reduce (1242)
• 30.6. Redukcja strumieni za pomocą metody collect (1245)
• 30.7. Grupowanie elementów za pomocą kolektora groupingBy (1248)
• 30.8. Studium przypadku (1251)

Rozdziały 31 - 37 są dostępne online pod adresem https://ftp.helion.pl/przyklady/wpja12.zip

Rozdział 31. Zaawansowane zagadnienia z obszaru JavaFX i FXML (1263)

• 31.1. Wprowadzenie (1264)
• 31.2. Style CSS z JavaFX (1264)
• 31.3. Klasy QuadCurve, CubicCurve i Path (1266)
• 31.4. Modyfikowanie współrzędnych (1271)
• 31.5. Pędzle (1276)
• 31.6. Menu (1280)
• 31.7. Menu kontekstowe (1285)
• 31.8. Panele SplitPane (1287)
• 31.9. Panele TabPane (1290)
• 31.10. TableView (1292)
• 31.11. Pisanie programów dla architektury JavaFX za pomocą języka FXML (1299)

Rozdział 32. Wielowątkowość i programowanie równoległe (1317)

• 32.1. Wprowadzenie (1318)
• 32.2. Zagadnienia związane z wątkami (1318)
• 32.3. Tworzenie zadań i wątków (1319)
• 32.4. Klasa Thread (1322)
• 32.5. Animacja z użyciem wątków i metody Platform.runLater (1325)
• 32.6. Pule wątków (1327)
• 32.7. Synchronizacja wątków (1329)
• 32.8. Synchronizacja z użyciem blokad (1333)
• 32.9. Współdziałanie między wątkami (1335)
• 32.10. Studium przypadku: wzorzec producent/konsument (1340)
• 32.11. Kolejki z blokowaniem (1343)
• 32.12. Semafory (1346)
• 32.13. Unikanie zakleszczenia (1347)
• 32.14. Stany wątków (1348)
• 32.15. Synchronizowane kolekcje (1349)
• 32.16. Programowanie równoległe (1350)

Rozdział 33. Sieci (1361)

• 33.1. Wprowadzenie (1362)
• 33.2. Model klient-serwer (1362)
• 33.3. Klasa InetAddress (1370)
• 33.4. Obsługa wielu klientów (1371)
• 33.5. Wysyłanie i przyjmowanie obiektów (1374)
• 33.6. Studium przypadku: kółko i krzyżyk w środowisku rozproszonym (1378)

Rozdział 34. Umiędzynarodowienie (1397)

• 34.1. Wprowadzenie (1398)
• 34.2. Klasa Locale (1398)
• 34.3. Wyświetlanie daty i czasu (1401)
• 34.4. Formatowanie liczb (1413)
• 34.5. Pakiety zasobów (1420)
• 34.6. Kodowanie znaków (1427)

Rozdział 35. Drzewa 2-3-4 i B-drzewa (1433)

• 35.1. Wprowadzenie (1434)
• 35.2. Projektowanie klas na potrzeby drzew 2-3-4 (1435)
• 35.3. Wyszukiwanie elementu (1435)
• 35.4. Wstawianie elementu w drzewie 2-3-4 (1437)
• 35.5. Usuwanie elementów z drzewa 2-3-4 (1439)
• 35.6. Odwiedzanie elementów w drzewie 2-3-4 (1443)
• 35.7. Implementowanie klasy Tree24 (1445)
• 35.8. Testowanie klasy Tree24 (1453)
• 35.9. Analiza złożoności czasowej (1455)
• 35.10. B-drzewo (1457)

Rozdział 36. Drzewa czerwono-czarne (1463)

• 36.1. Wprowadzenie (1464)
• 36.2. Konwersja między drzewami czerwono-czarnymi a drzewami 2-3-4 (1464)
• 36.3. Projektowanie klas drzew czerwono-czarnych (1466)
• 36.4. Przesłanianie metody insert (1467)
• 36.5. Przesłanianie metody delete (1472)
• 36.6. Implementowanie klasy RBTree (1482)
• 36.7. Testowanie klasy RBTree (1489)
• 36.8. Wydajność klasy RBTree (1492)

Rozdział 37. Testy z użyciem JUnit (1497)

• 37.1. Wprowadzenie (1498)
• 37.2. Podstawy JUnit (1498)
• 37.3. Używanie JUnit w NetBeans (1504)
• 37.4. Używanie JUnit w Eclipse (1507)

Dodatek A Słowa kluczowe i zarezerwowane w Javie (1513)

Dodatek B Zestaw znaków ASCII (1515)

Dodatek C Tabela priorytetów operatorów (1517)

Dodatek D Modyfikatory w Javie (1519)

Dodatek E Specjalne wartości zmiennoprzecinkowe (1521)

Dodatek F Systemy liczbowe (1523)

Dodatek G Operacje bitowe (1527)

Dodatek H Wyrażenia regularne (1529)

Dodatek I Typy wyliczeniowe (1537)

Dodatek J Notacje dużego O, dużego omega i dużego theta (1543)