Wprowadzenie do Javy. Programowanie i struktury danych. Wydanie XII - Helion
Tytuł oryginału: Introduction to Java Programming and Data Structures, Comprehensive Version (12th Edition)
Tłumaczenie: Tomasz Walczak
ISBN: 978-83-283-7082-1
stron: 1544, Format: 200x225, okładka: twarda
Data wydania: 2021-08-31
Księgarnia: Helion
Cena książki: 59,90 zł (poprzednio: 193,23 zł)
Oszczędzasz: 69% (-133,33 zł)
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!
Osoby które kupowały "Wprowadzenie do Javy. Programowanie i struktury danych. Wydanie XII", wybierały także:
- JavaFX. Kurs video. Wzorce oraz typy generyczne 79,00 zł, (31,60 zł -60%)
- Platforma Xamarin. Kurs video. Poziom drugi. Zaawansowane techniki tworzenia aplikacji cross-platform 99,00 zł, (39,60 zł -60%)
- Spring Security. Kurs video. Skuteczne metody zabezpieczeń aplikacji 69,00 zł, (27,60 zł -60%)
- JUnit - testy jednostkowe. Kurs video. Automatyzacja procesu testowania w Javie 79,00 zł, (31,60 zł -60%)
- Algorytmy i struktury danych. Kurs video. Java, JavaScript, Python 89,00 zł, (40,05 zł -55%)
Spis treści
Wprowadzenie do Javy. Programowanie i struktury danych. Wydanie XII -- spis treści
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)