Pacchetti della libreria standard Java

Il JDK include una vasta libreria standard, organizzata in centinaia di pacchetti. Nei primi mesi si ricorrerà sempre agli stessi pochi: java.lang, java.util, java.io, java.nio, java.net, java.time, java.math. Questo capitolo è una panoramica — a cosa serve ciascuno, le classi principali che contiene e quando usarlo rispetto ai vicini.

`java.lang` — il pacchetto che non si importa mai

java.lang viene importato automaticamente in ogni file sorgente. Tutto ciò che contiene è disponibile con il nome semplice, senza una sola riga import:

Object, Class, String, StringBuilder — i tipi che ogni programma utilizza.
Math — sqrt, min, max, random, le funzioni trigonometriche.
Tipi wrapper — Integer, Long, Double, Boolean, Character, Byte, Short.
Thread, Runnable, ThreadLocal — le primitive originali per la concorrenza.
System — out, err, currentTimeMillis(), getenv, exit.
Throwable, Exception, RuntimeException, Error — l'intera gerarchia delle eccezioni.
Iterable, Comparable, CharSequence, AutoCloseable — interfacce su cui il linguaggio si basa per for-each, i generici, try-with-resources e altro.

Se si vede una classe usata senza un import, quasi sempre proviene da qui.

`java.util` — collezioni, utilità e le vecchie classi per le date

java.util è il pacchetto di uso quotidiano. Solo il framework delle collezioni è motivo sufficiente per conoscerlo.

Interfacce delle collezioni: Collection, List, Set, Map, Queue, Deque.
Implementazioni concrete: ArrayList, LinkedList, HashMap, LinkedHashMap, TreeMap, HashSet, TreeSet, ArrayDeque.
Classi di utilità: Arrays (metodi per array), Collections (sort, unmodifiableList, ...), Objects (requireNonNull, hash).
Optional — per i tipi di ritorno che "potrebbero non avere un valore."
Random, Scanner, UUID — utilità comuni che si trovano ovunque.
Le vecchie classi per le date — Date, Calendar, TimeZone. Non usarle nel nuovo codice; usa invece java.time.

java.util ha anche importanti sotto-pacchetti da conoscere:

java.util.concurrent — ConcurrentHashMap, ExecutorService, Future, CompletableFuture, la cassetta degli attrezzi moderna per la concorrenza.
java.util.stream — la Stream API per pipeline in stile funzionale.
java.util.function — interfacce funzionali: Function, Predicate, Supplier, Consumer, la famiglia usata da stream e lambda.

`java.io` — stream classici

Il pacchetto I/O originale, ancora ampiamente utilizzato ovunque anche se java.nio è ora preferito per il nuovo codice.

Stream di byte: InputStream, OutputStream, FileInputStream, FileOutputStream, BufferedInputStream, ByteArrayInputStream.
Stream di caratteri: Reader, Writer, FileReader, FileWriter, BufferedReader, InputStreamReader, PrintWriter.
File — l'astrazione legacy del file system.
Serializzazione: Serializable, ObjectInputStream, ObjectOutputStream.

La distinzione tra stream di byte (InputStream/OutputStream) e stream di caratteri (Reader/Writer) è intenzionale — i byte per i dati binari, i caratteri per il testo con una codifica nota.

`java.nio` — I/O moderno e percorsi

"NIO" significava originariamente "new I/O"; oggi è semplicemente il pacchetto I/O consigliato.

java.nio.file.Path — il sostituto moderno di java.io.File.
java.nio.file.Files — helper pronti all'uso: Files.readString, Files.write, Files.walk, Files.exists.
java.nio.file.Paths — punto di accesso più datato; Path.of(...) fa la stessa cosa con meno codice.
Buffer e channel: ByteBuffer, FileChannel, SocketChannel — blocchi di costruzione di basso livello per I/O ad alte prestazioni.

Per il nuovo codice che legge un file: ricorrere a Files.readString(Path.of(...)), non a BufferedReader con un try-with-resources.

`java.net` — rete

URL, socket e HTTP.

URL, URI — analisi e rappresentazione degli indirizzi.
Socket, ServerSocket, DatagramSocket — TCP e UDP a basso livello.
InetAddress — indirizzi IP e risoluzione dei nomi host.

Java 11 ha aggiunto java.net.http.HttpClient, un client HTTP moderno con supporto asincrono integrato nel JDK. Per il nuovo codice che effettua richieste HTTP, questo è il punto di partenza corretto — nessuna libreria di terze parti richiesta.

`java.time` — date e ore fatte bene

Aggiunto in Java 8 per sostituire la problematica API Date / Calendar.

LocalDate, LocalTime, LocalDateTime — valori dell'orologio a parete, senza fuso orario.
ZonedDateTime, ZoneId — momenti con consapevolezza del fuso orario.
Instant — un punto sulla linea temporale globale; il tipo da conservare nei database.
Duration, Period — quantità di tempo (secondi vs. giorni/mesi).
DateTimeFormatter — analisi e formattazione.

Tutti i tipi di java.time sono immutabili e thread-safe. Questo da solo è sufficiente per migrare qualsiasi codice che utilizza ancora java.util.Date.

`java.math` — aritmetica precisa

Quando double e long non bastano:

BigInteger — interi a precisione arbitraria; nessun overflow.
BigDecimal — aritmetica decimale esatta con una modalità di arrotondamento esplicita; quello che si vuole per il denaro.

MathContext e RoundingMode completano il pacchetto.

Altri che incontrerai

java.text — formattazione più datata (NumberFormat, MessageFormat). In gran parte superato da java.time e String.format, ma ancora comune nell'output localizzato.
java.security — hashing, firma digitale; MessageDigest, KeyStore, Signature.
javax.crypto — crittografia simmetrica e asimmetrica.
java.sql — API JDBC.
javax.xml, org.w3c.dom, org.xml.sax — analisi XML.

I prefissi javax.* e org.* sono storici — javax era originariamente per le "estensioni", e i pacchetti org.* provenivano da organismi di standardizzazione. Oggi sono pacchetti JDK ordinari come gli altri.

Un esempio pratico

Questo programma attinge da java.util, java.util.stream, java.time e java.math in un unico posto — un'istantanea di come si compone la libreria standard.

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));
  }
}

Stampa:

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

Si noti che i totali sono esatti (BigDecimal non ha mai perso un centesimo), i giorni sono raggruppati in ordine cronologico (il supplier TreeMap li ha ordinati), e il divario tra le date viene calcolato senza un singolo calcolo manuale in millisecondi. Lo stesso programma sarebbe il doppio più lungo e confuso con i equivalenti pre-Java-8 Date/Calendar e double per il denaro. Scegliere il pacchetto giusto è metà della battaglia.

Cosa c'è dopo

Hai visto ora cosa contiene la libreria standard. L'ultimo tassello della storia dei pacchetti è come la JVM trova effettivamente tutte quelle classi — le tue e quelle del JDK — in fase di compilazione e runtime. Continua con il classpath Java.

Esercizio

Pratica

Un nuovo progetto Java deve gestire prezzi e date. A quali pacchetti dovresti ricorrere?

`java.math.BigDecimal` per il denaro e `java.time` (ad es. `LocalDate`, `DateTimeFormatter`) per le date — entrambi sono progettati per questo e evitano i bug di arrotondamento di `double` e la mutabilità delle classi legacy `Date`/`Calendar``double` per il denaro e `java.util.Date` più `java.text.SimpleDateFormat` per le date — queste sono le scelte standard del JDK`java.lang.Number` per il denaro e `java.util.Calendar` per le date — entrambi sono immutabili e thread-safeUsare sempre librerie di terze parti (Joda-Time, JodaMoney) perché il JDK non include nulla di adatto

java.lang — il pacchetto che non si importa mai

java.util — collezioni, utilità e le vecchie classi per le date

java.io — stream classici

java.nio — I/O moderno e percorsi

java.net — rete

java.time — date e ore fatte bene

java.math — aritmetica precisa