Die besten Java Bücher
(aktualisiert 2024)

Effective Java (Third Edition)

von Joshua Bloch

Link zum Buch bei Amazon

In diesem Buch hat Joshua Bloch die wichtigsten Do's und Dont's der Java-Programmierung zusammengestellt: Best Practices, die dir helfen effiziente, les- und wartbare – und damit zukunftssichere – Software zu schreiben.

Das Buch richtet sich vor allem an erfahrene Java-Programmierer – gute Kenntnisse der Sprache werden vorausgesetzt.

Einige der Praktiken wendest du sicherlich im Alltag bereits an; andere können neu für dich sein und dir helfen deine Fähigkeiten auf die nächste Stufe zu heben.

Das Buch enthält 90 Artikel, die in 11 Themen gegliedert sind. Eine Menge Stoff – man kann ihn sich aber gut nach und nach zu Gemüte führen. Denn die Artikel stellen jeweils eine in sich abgeschlossene Einheit dar.

Jeder Artikel enthält spezifische, gut verständliche Ratschläge, die von prägnanten, anschaulichen Code-Beispielen begleitet werden.

Jeder Java-Programmierer sollte dieses Buch gelesen haben. Ich empfehle dir das Buch einmal komplett zu lesen und dann, wenn du im Programmieralltag spezifische Aufgabenstellungen lösen musst, die entsprechenden Artikel noch einmal zu konsultieren.

Achte beim Kauf unbedingt darauf (insbesondere, wenn du gebraucht kaufst), dass du die aktuelle, dritte Ausgabe erwirbst! Die zweite Ausgabe ist auf dem Stand von Java 6 und nicht mehr aktuell.

Deutsche Übersetzung: Effective Java: Best Practices für die Java-Plattform

Als Hörbuch geeignet? Nein, wegen der zahlreichen Code-Beispiele.

Java Concurrency in Practice

von Brian Goetz, Tim Peilers, Joshua Bloch, Joseph Bowbeer, Davod Holmes, Doug Lea

Link zum Buch bei Amazon

Skalierbare Anwendungen zu schreiben, die die Fähigkeiten der heutigen Multicore-CPUs nutzen und dabei zuverlässig und performant laufen, ist eine Herausforderung. Schnell schleichen sich Race Conditions, Deadlocks und andere Liveness-Fehler ein.

Brian Goetz und ein Team von Experten aus dem Java Specification Request 166 "Concurrency Utilities" beschreiben in “Java Concurrency in Practice” grundlegende Konzepte der Threadsicherheit und die korrekte Implementierung threadsicherer Anwendungen in Java.

Das Buch ist in vier Teile gegliedert:

1. Im ersten Teil geht es um Grundlagen wie Atomarität und Sichtbarkeit, um intrinsische Locks (“synchronized”), sichere Veröffentlichung von Objekten, threadsichere Komposition und Concurrency-Bausteine wie Concurrent Collections und Synchronizer wie Semaphore, Latches und Barrieren.
2. Im zweiten Teil geht es um die Parallelisierung von Anwendungen mithilfe von Tasks und dem Executor Framework. Erklärt werden die Konfiguration von Thread Pools und das sichere Beenden von Tasks, Threads, Thread Pools und Anwendungen.
3. Im dritten Teil geht es um Liveness (Deadlocks, Livelocks, Thread Starvation), um Messung von Performance und deren Verbesserung durch Reduzierung von Lock Contention und um das Schreiben von Tests für nebenläufige Algorithmen.
4. Im vierten Teil geht es um fortgeschrittene Themen wie explizite Locks, Condition Queues (wait/notify), atomare Variablen, nicht-blockierende Algorithmen und das Java Memory Model. Darauf aufbauend wird die Funktionsweise vieler im ersten Teil vorgestellter Themen, wie Objekt-Veröffentlichung, Concurrent Collections und Synchronizer-Klassen, erläutert.

Die Erklärungen werden von hervorragenden praxisnahen Beispielen begleitet. Die meisten zeigen zuerst häufig gemachte, aber falsche Implementierungen – gefolgt von den richtigen.

Den Autoren gelingt es ein äußerst komplexes Thema auf relativ einfache Weise zu erklären. Besonders hervorzuheben ist die ausgezeichnete Erklärung des Java Memory Models und der “happens-before”-Beziehung.

Dennoch ist das Buch keine einfache Lektüre, und es braucht Zeit, um alle Details zu verstehen. Ich empfehle das Buch mindestens zweimal zu lesen.

Auch wenn das Buch auf dem Stand von Java 6 ist, ist es nach wie vor aktuell. An den Grundlagen der Threadsicherheit hat sich seither nichts geändert, und alle in späteren Java-Versionen hinzugekommenen Features (wie das Fork/Join-Framework, CompletableFuture oder parallele Streams) basieren darauf.

Geeignet als Hörbuch? Nein, aufgrund zahlreicher umfangreicher Codebeispiele.

P.S.: Wer noch tiefer in die fortgeschrittene Thematik einsteigen möchte, und z. B. über spezifische Arten von Memory Fences und fortgeschrittene Speicherzugriffsmethoden wie Release/Acquire und Opaque lesen möchte, dem empfehle ich als Folgelektüre Doug Leas “Concurrent Programming in Java”.

Java Generics and Collections

von Maurice Naftalin und Philip Wadler

Link zum Buch bei Amazon

Während die Einführung in Generics heutzutage von den meisten Java-Entwickler übersprungen werden kann, geht es schnell an die fortgeschrittenen Themen wie Subtyping, Wildcards, Wildcard Captures und Bounds – Themen, mit denen jeder Java-Programmierer sicher schon einmal zu tun hatte, bei denen sich viele dann aber doch eher an Compiler-Fehlern entlanghangeln anstatt genau zu wissen, was sie tun.

Im zweiten Teil des Buches werden die wichtigsten Collection-Interfaces und -Klassen des Java Collection Frameworks – Sets, Queues, Lists und Maps sowie deren Implementierungen – vorgestellt und im Hinblick auf nebenläufige Programmierung und Performance verglichen.

Jeder fortgeschrittene Java-Programmierer sollte mit diesen Themen vertraut sein!

Geeignet als Hörbuch? Nein, aufgrund zahlreicher Codebeispiele.

Core Java: Fundamentals (Band 1)
Core Java: Advanced Features (Band 2)

von Cay S. Horstmann

Link zu Band 1 bei Amazon
Link zu Band 2 bei Amazon

„Core Java” ist seit 25 Jahren das Standardwerk für angehende und fortgeschrittene Java-Programmierer. Für die nunmehr dreizehnte Auflage hat Autor Cay Horstmann, ehemaliger Professor für Informatik, Java Champion und häufiger Redner auf Konferenzen den Inhalt für Java 21 komplett überarbeitet und modernisiert.

Band I beginnt mit einer gründlichen Einführung in die Programmiersprache Java, wobei grundlegende Programmierkenntnisse vorausgesetzt werden. Der Leser erfährt alles über die in Java verfügbaren Datentypen und Operatoren, über Enums, Klassen, Interfaces, Vererbung und Polymorphismus, über Lambda-Ausdrücke, über Ausnahmebehandlung, über das Java Collection Framework und Generics, über Multithreading, über Annotationen, über Reflection und Proxies, über das Modulsystem bis hin zu neuen Features wie Switch-Ausdrücken, Textblöcken, Records, versiegelten Klassen, Sequenced Collections, Pattern Matching und virtuellen Threads.

Band II richtet sich an erfahrene Java-Programmierer, die komplexere Anwendungen entwickeln möchten. Er behandelt Streams, I/O über Dateien und das Netzwerk, Datenbankprogrammierung mit JDBC, die Verarbeitung von XML-Dateien, die Internationalisierung von Anwendungen, Authentifizierung, Autorisierung und Kryptografie, die Entwicklung von Benutzeroberflächen mit Swing und den Zugriff auf nativen Code über JNI. Band II schließt mit einer Vorschau auf “Projekt Panama”, welches JNI durch die modernere Foreign Function & Memory API ersetzen wird.

Alles in allem deckt Core Java eine breite Palette von Themen ab, geht aber bei jedem in die Tiefe, sodass nicht nur Anfänger, sondern auch fortgeschrittene Java-Programmierer viel lernen können.

Beide Bände sind didaktisch hervorragend aufgebaut, nachvollziehbar, präzise und detailliert, teilweise sogar humorvoll und unterhaltsam geschrieben. Sie enthalten hunderte von praxisnahen Code-Beispielen, die der Autor auch für ältere Themen auf neue Sprachfeatures modernisiert hat.

„Core Java” ist ein ausgezeichnetes Lehr- und Nachschlagewerk, das ich allen Java-Programmiererinnen und -Programmierern, unabhängig von ihrem Erfahrungsstand, uneingeschränkt empfehle.

Geeignet als Hörbuch? Nein, aufgrund zahlreicher Codebeispiele.

Concurrent Programming in Java: Design Principles and Pattern, 2nd Edition

von Doug Lea

Link zum Buch bei Amazon

Concurrency ist seit jeher ein First-Class-Citizen in Java. Threads, Monitore (Stichwort "synchronized") und Guarded Blocks ("wait"/"notify") sind seit Java 1.0 Teil der Sprache.

"Concurrent Programming in Java" ist von 1999 und damit auf dem Stand von Java 1.2. Dennoch sind die beschriebenen Herausforderungen der nebenläufigen Programmierung (Sicherheit, Liveness, Performance) auch heute noch aktuell. Das gilt auch für die vorgestellten Prinzipien und Entwurfsmuster, wie Synchronisation und Confinement, Monitore, Guarded Waits und Notifications, Latches, Worker Threads, Futures, Fork/Join und viele mehr.

Davon abstrahierend stellt der Autor komplexere, wiederverwendbare Utility-Klassen für die Initiierung und Koordination nebenläufiger Aktivitäten vor. Die meisten dieser Klassen sind heute – in weiterentwickelter Form – Bestandteil des JDK. Im JavaDoc dieser Klassen (z. B. Semaphore, ReentrantLock, Executor oder CountDownLatch – und auch in neueren wie CompletableFuture oder StampedLock) findest du die Signatur von Doug Lea, dem Autor dieses Buches.

Das Buch ist keine leichte Lektüre. Der Schreibstil ist akademisch und äußerst anspruchsvoll. Ich musste viele Absätze mehr als einmal lesen und zum Verständnis immer wieder Querverweisen zu andere Teilen des Buches folgen. Bei den Beispielen ist es mitunter ratsam, zuerst die Theorie zu lesen, dann den Quellcode und dann noch einmal die Theorie. Alle paar Seiten muss man eine Pause einlegen.

Ich habe mehrere Wochen gebraucht, um das gesamte Werk durchzuarbeiten. Aber die Mühe lohnt sich auf jeden Fall!

Wenn du die Grundlagen dieses Buchs verinnerlicht hast, wirst du in der Lage sein performanten, thread-sicheren Code zu schreiben und nicht-thread-sicheren Code sowie die Ursachen von Race Conditions schnell zu erkennen. Das wird dich zu einem der gefragtesten Java-Programmierer machen.

Geeignet als Hörbuch? Nein, aufgrund zahlreicher Diagramme und Codebeispiele.

Java Puzzlers: Traps, Pitfalls, and Corner Cases

von Joshua Bloch und Neal Gafter

Link zum Buch bei Amazon

In diesem sehr unterhaltsamen Buch decken Joshua Bloch und Neil Gafter, beide Mitentwickler der Java-Plattform, zahlreiche Fallstricke und Eckfälle der Java-Plattform auf.

Das Buch enthält 95 Rätsel in Form eines wenige Zeilen langen, scheinbar trivialen Java-Programms. Die Aufgabe des Lesers besteht darin, vorherzusagen, was das Programm tun wird. Die offensichtliche Antwort ist selten die richtige – und selbst wenn man die Falle erkennt, die die Autoren einem gestellt haben, tappt man oft in eine zweite, noch obskurere Falle.

Zu jedem Rätsel beschreiben die Autoren detailliert die Gründe für das unerwartete Verhalten (mit Verweisen auf die Java Language Specification) und liefern praktische Regeln, um das gezeigte Verhalten von vornherein zu vermeiden.

Einige der Rätsel sind stark konstruiert, um Ausnahmeregelungen aus den Tiefen der Java-Sprachspezifikation greifen zu lassen, mit denen ich in 25 Jahren Java noch kein einziges Mal zu tun hatte. Denn die meisten dieser Kuriositäten treten nicht auf, wenn man sauberen, lesbaren Code ohne „clevere” Tricks schreibt.

Vielen der Fälle begegnet man jedoch regelmäßig, wie z. B. dem %-Operator, den Eigenheiten vorzeichenbehafteter Integer-Typen, Ungenauigkeiten bei Fließkommazahlen, stillen Überläufen, versteckten (statt überschriebenen oder überladenen) Methoden oder der Initialisierung statischer Klassenvariablen, um nur einige zu nennen.

Jedes einzelne Rätsel ist spannend und lehrreich, und die Erklärungen sind humorvoll und unterhaltsam. Sehr amüsant ist, dass die Namen einiger Rätsel einen Hinweis auf die Lösung geben. Das mindert aber keineswegs den Spaß, denn man merkt es in der Regel erst hinterher beim großen „Aha”-Moment.

Das einzige Manko des Buchs ist, dass es auf dem Stand von Java 5 ist. Einige der Besonderheiten treten in modernen Java-Versionen nicht mehr auf – dafür gibt es sicherlich einige neue.

Als Hörbuch geeignet? Nein, wegen der zahlreichen Code-Beispiele.

Mastering Lambdas: Java Programming in a Multicore World

von Maurice Naftalin

Link zum Buch bei Amazon

Dieses ist eine großartiges Buch über die in Java 8 eingeführten Lambdas und Streams. Trotz der Präsenz im Titel, nehmen Lambdas nur etwa das erste Viertel des Buches ein. Der größte Teil beschreibt Streams: wie man sie benutzt, wie man sie erzeugt und wie man sie mit Hilfe von Collectoren und Reducern terminiert.

Ich empfehle dieses Buch sowohl Anfängern als auch Fortgeschrittenen. Anfänger werden Schritt für Schritt in die Funktionsweise von Lambdas und – darauf aufbauend – Streams herangeführt. Für Fortgeschrittene geht es über die Programmierung von Spliterators zur Erzeugung von Streams bis hin zu individuellen Collectoren und Reducern.

Geeignet als Hörbuch? Nein, aufgrund zahlreicher Diagramme und Codebeispiele.

Bad Tests, Good Tests

von Tomek Kaczanowski

Link zum Buch bei Amazon

Tests und testgetriebene Entwicklung (TDD) sind in den meisten IT-Teams angekommen. Tests sollen das korrekte Verhalten neuer und bestehender Features sicherstellen, dabei Refactorings unbeschadet überstehen, als Dokumentation neuen Entwicklern den Einstieg in den Code erleichtern und – obendrein – zu sauber(er)em Code führen.

Leider sind viele Tests die Zeit nicht wert, die in ihre Entwicklung investiert wird. Sie sind schlecht les- und wartbar. Und oft müssen sie bei Refactorings angepasst werden, da sie nicht das Resultat einer Operation verifizieren, sondern wie die Operation ausgeführt wurde.

Bad Tests, Good Tests erklärt anhand zahlreicher Beispiele (etwa die Hälfte des Buches enthält Code) was schlechte Tests ausmacht – Beispiele, wie der Autor sie in realen Projekten vorgefunden hat. Jedem Beispiel stellt der Autor dann konkrete Verbesserungsvorschläge gegenüber.

Die Bandbreite der Mängel reicht von schlechter Lesbarkeit (z. B. lange Setup- oder Assertion-Blöcke) und offensichtlichen Fehlern (z. B. vergessene Assertions) über lückenhafte Tests (die trotz geänderter Funktionalität nicht fehlschlagen) und subtile Fehler (z. B. Exceptions, die an anderen Stellen als erwartet geworfen werden) bis hin zu völlig unnützen Tests (die z. B. die Test-Library verifizieren anstatt den eigenen Code).

Das Buch ist außerordentlich praxisnah und sowohl für Anfänger als auch für fortgeschrittene Entwickler geeignet.

Anfänger müssen die Fehler nicht wiederholen, die andere vor ihnen gemacht haben. Fortgeschrittene Programmierer werden sicher das eine oder andere Anti-Pattern aus ihrer täglichen Arbeit wiedererkennen und können ihre Toolbox mit neuen Techniken füllen.

Der Autor schreibt verständlich und humorvoll. Und er weist ausdrücklich darauf hin, dass man seine Regeln auch brechen darf, wenn es im Einzelfall der Sache dient.

Eine klare Empfehlung für jeden Java-Entwickler.

Geeignet als Hörbuch? Nein, aufgrund zahlreicher Codebeispiele.