Java-Standardbibliothek-Pakete

Das JDK wird mit einer umfangreichen Standardbibliothek ausgeliefert, die in Hunderte von Paketen unterteilt ist. In den ersten Monaten greift man immer wieder auf dieselbe Handvoll zurück: java.lang, java.util, java.io, java.nio, java.net, java.time, java.math. Dieses Kapitel gibt einen Überblick — wofür jedes Paket gedacht ist, welche wichtigsten Klassen es enthält und wann man es statt seiner Nachbarpakete nutzen sollte.

`java.lang` — das Paket, das man nie importiert

java.lang wird automatisch in jede Quelldatei importiert. Alles darin ist ohne eine einzige import-Zeile unter seinem einfachen Namen verfügbar:

Object, Class, String, StringBuilder — die Typen, die jedes Programm verwendet.
Math — sqrt, min, max, random, die trigonometrischen Funktionen.
Wrapper-Typen — Integer, Long, Double, Boolean, Character, Byte, Short.
Thread, Runnable, ThreadLocal — die ursprünglichen Concurrency-Primitive.
System — out, err, currentTimeMillis(), getenv, exit.
Throwable, Exception, RuntimeException, Error — die gesamte Exception-Hierarchie.
Iterable, Comparable, CharSequence, AutoCloseable — Interfaces, auf die die Sprache selbst für for-each, Generics, try-with-resources und Ähnliches angewiesen ist.

Wenn eine Klasse ohne Import verwendet wird, stammt sie fast immer von hier.

`java.util` — Collections, Hilfsmittel und die alten Datumsklassen

java.util ist das täglich genutzte Paket. Das Collections-Framework allein ist Grund genug, es zu kennen.

Collection-Interfaces: Collection, List, Set, Map, Queue, Deque.
Konkrete Implementierungen: ArrayList, LinkedList, HashMap, LinkedHashMap, TreeMap, HashSet, TreeSet, ArrayDeque.
Hilfsklassen: Arrays (Array-Methoden), Collections (sort, unmodifiableList, ...), Objects (requireNonNull, hash).
Optional — für Rückgabetypen, die „möglicherweise keinen Wert haben."
Random, Scanner, UUID — häufig verwendete Hilfsmittel, die überall vorkommen.
Die alten Datumsklassen — Date, Calendar, TimeZone. Diese nicht in neuem Code verwenden; stattdessen java.time nutzen.

java.util hat außerdem wichtige Unterpakete, die man kennen sollte:

java.util.concurrent — ConcurrentHashMap, ExecutorService, Future, CompletableFuture, der moderne Concurrency-Werkzeugkasten.
java.util.stream — die Stream API für funktionale Pipelines.
java.util.function — funktionale Interfaces: Function, Predicate, Supplier, Consumer, die Familie, die von Streams und Lambdas verwendet wird.

`java.io` — klassische Streams

Das ursprüngliche I/O-Paket, das überall noch aktiv genutzt wird, obwohl java.nio für neuen Code bevorzugt wird.

Byte-Streams: InputStream, OutputStream, FileInputStream, FileOutputStream, BufferedInputStream, ByteArrayInputStream.
Zeichen-Streams: Reader, Writer, FileReader, FileWriter, BufferedReader, InputStreamReader, PrintWriter.
File — die veraltete Dateisystem-Abstraktion.
Serialisierung: Serializable, ObjectInputStream, ObjectOutputStream.

Die Trennung zwischen Byte-Streams (InputStream/OutputStream) und Zeichen-Streams (Reader/Writer) ist bewusst gewählt — Bytes für Binärdaten, Zeichen für Text mit bekannter Kodierung.

`java.nio` — modernes I/O und Pfade

„NIO" bedeutete ursprünglich „new I/O"; heute ist es einfach das empfohlene I/O-Paket.

java.nio.file.Path — der moderne Ersatz für java.io.File.
java.nio.file.Files — Einzeilen-Helfer: Files.readString, Files.write, Files.walk, Files.exists.
java.nio.file.Paths — älterer Einstiegspunkt; Path.of(...) erledigt dasselbe mit weniger Code.
Puffer und Kanäle: ByteBuffer, FileChannel, SocketChannel — Low-Level-Bausteine für hochleistungsfähiges I/O.

Für neuen Code, der eine Datei liest: Files.readString(Path.of(...)) verwenden, nicht BufferedReader mit try-with-resources.

`java.net` — Netzwerk

URLs, Sockets und HTTP.

URL, URI — Parsen und Darstellen von Adressen.
Socket, ServerSocket, DatagramSocket — Low-Level-TCP und -UDP.
InetAddress — IPs und Hostname-Auflösung.

Java 11 hat java.net.http.HttpClient hinzugefügt, einen modernen, asynchronen HTTP-Client, der in das JDK integriert ist. Für neuen Code, der HTTP-Anfragen stellt, ist das der richtige Ausgangspunkt — keine Drittanbieter-Bibliothek erforderlich.

`java.time` — Datum und Uhrzeit richtig gemacht

In Java 8 hinzugefügt, um die fehlerhafte Date/Calendar-API zu ersetzen.

LocalDate, LocalTime, LocalDateTime — Wanduhr-Werte, ohne Zeitzone.
ZonedDateTime, ZoneId — zeitzonenbewusste Zeitpunkte.
Instant — ein Punkt auf der globalen Zeitlinie; der Typ zum Speichern in Datenbanken.
Duration, Period — Zeitmengen (Sekunden vs. Tage/Monate).
DateTimeFormatter — Parsen und Formatieren.

Alle java.time-Typen sind unveränderlich und thread-sicher. Das allein ist Grund genug, jeden Code zu migrieren, der noch java.util.Date verwendet.

`java.math` — präzise Arithmetik

Wenn double und long nicht ausreichen:

BigInteger — ganzzahlige Arithmetik mit beliebiger Genauigkeit; kein Überlauf.
BigDecimal — exakte Dezimalarithmetik mit einem expliziten Rundungsmodus; das Richtige für Geldbeträge.

MathContext und RoundingMode runden das Paket ab.

Einige weitere, denen man begegnen wird

java.text — ältere Formatierung (NumberFormat, MessageFormat). Größtenteils durch java.time und String.format abgelöst, aber bei lokalisierten Ausgaben noch verbreitet.
java.security — Hashing, Signierung; MessageDigest, KeyStore, Signature.
javax.crypto — symmetrische und asymmetrische Verschlüsselung.
java.sql — JDBC API.
javax.xml, org.w3c.dom, org.xml.sax — XML-Verarbeitung.

Die Präfixe javax.* und org.* sind historisch bedingt — javax stand ursprünglich für „extensions", und org.*-Pakete kamen von Standardisierungsgremien. Heute sind sie ganz normale JDK-Pakete wie alle anderen.

Ein ausgearbeitetes Beispiel

Dieses Programm nutzt java.util, java.util.stream, java.time und java.math an einem Ort — ein Schnappschuss davon, wie die Standardbibliothek zusammenwirkt.

java— editable, runs on the server

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.LocalDate;
import java.time.Month;
import java.time.Period;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.stream.Collectors;

public class StdLibTour {
  record Sale(String item, BigDecimal price, LocalDate when) {}

public static void main(String[] args) {
    // java.util.List + java.math.BigDecimal + java.time.LocalDate
    List<Sale> sales = List.of(
      new Sale("Book", new BigDecimal("29.99"), LocalDate.of(2026, Month.JANUARY,  4)),
      new Sale("Pen",  new BigDecimal("3.50"),  LocalDate.of(2026, Month.JANUARY,  4)),
      new Sale("Mug",  new BigDecimal("12.00"), LocalDate.of(2026, Month.JANUARY, 17))
    );

// java.util.stream — group by day and sum BigDecimal totals exactly.
    Map<LocalDate, BigDecimal> byDay = sales.stream().collect(Collectors.groupingBy(
      Sale::when,
      TreeMap::new,
      Collectors.reducing(BigDecimal.ZERO, Sale::price, BigDecimal::add)
    ));

// java.time.format — render dates in a readable form.
    DateTimeFormatter fmt = DateTimeFormatter.ofPattern("d MMM yyyy");
    byDay.forEach((day, total) ->
      System.out.printf("%s -> $%s%n",
        day.format(fmt),
        total.setScale(2, RoundingMode.HALF_UP)));

// java.time.Period — distance between two dates.
    LocalDate today = LocalDate.of(2026, Month.FEBRUARY, 1);
    Period gap = Period.between(sales.get(0).when(), today);
    System.out.println("first sale was " + gap.getDays() + " days before " + today.format(fmt));
  }
}

Die Ausgabe lautet:

4 Jan 2026 -> $33.49
17 Jan 2026 -> $12.00
first sale was 28 days before 1 Feb 2026

Man beachte: Die Summen sind exakt (BigDecimal hat keinen Cent verloren), die Tage sind in Kalenderreihenfolge gruppiert (der TreeMap-Supplier hat sie sortiert), und der Datumsabstand wird ohne eine einzige manuelle Millisekundenberechnung ermittelt. Dasselbe Programm wäre mit den Entsprechungen vor Java 8 — Date/Calendar und double für Geld — doppelt so lang und unübersichtlicher. Das richtige Paket zu wählen ist die halbe Miete.

Was kommt als Nächstes

Du hast nun gesehen, was in der Standardbibliothek steckt. Das letzte Stück der Pakete-Geschichte ist, wie die JVM all diese Klassen — deine eigenen und die des JDK — zur Compile-Zeit und zur Laufzeit tatsächlich findet. Weiter zum Java-Classpath.

Übungen

Übung

Ein neues Java-Projekt muss Preise und Datumsangaben verwalten. Welche Pakete sollte man verwenden?

`java.math.BigDecimal` für Geldbeträge und `java.time` (z. B. `LocalDate`, `DateTimeFormatter`) für Datumsangaben — beide sind dafür ausgelegt und vermeiden die Rundungsfehler von `double` sowie die Veränderlichkeit der veralteten `Date`/`Calendar`-Klassen`double` für Geldbeträge und `java.util.Date` zusammen mit `java.text.SimpleDateFormat` für Datumsangaben — das sind die Standard-JDK-Optionen`java.lang.Number` für Geldbeträge und `java.util.Calendar` für Datumsangaben — beide sind unveränderlich und thread-sicherImmer Drittanbieter-Bibliotheken verwenden (Joda-Time, JodaMoney), weil das JDK nichts Geeignetes mitliefert

java.lang — das Paket, das man nie importiert

java.util — Collections, Hilfsmittel und die alten Datumsklassen

java.io — klassische Streams

java.nio — modernes I/O und Pfade

java.net — Netzwerk

java.time — Datum und Uhrzeit richtig gemacht

java.math — präzise Arithmetik