Helion


Szczegóły ebooka

Wprowadzenie do Javy. Programowanie i struktury danych. Wydanie XII

Wprowadzenie do Javy. Programowanie i struktury danych. Wydanie XII

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)

  • Tytuł: Wprowadzenie do Javy. Programowanie i struktury danych. Wydanie XII
  • Autor: Y. Daniel Liang
  • Tytuł oryginału: Introduction to Java Programming and Data Structures, Comprehensive Version (12th Edition)
  • Tłumaczenie: Tomasz Walczak
  • ISBN książki drukowanej: 978-83-283-7082-1, 9788328370821
  • Data wydania książki drukowanej: 2021-08-31
  • ISBN Ebooka: 978-83-283-7083-8, 9788328370838
  • Data wydania ebooka: 2021-08-31
  • Format: 200x225
  • Identyfikator pozycji: wpja12
  • Wydawca: Helion