Packages de la bibliothèque standard Java

Le JDK est livré avec une vaste bibliothèque standard, organisée en des centaines de packages. Vous passerez vos premiers mois à utiliser sans cesse la même poignée d'entre eux : java.lang, java.util, java.io, java.nio, java.net, java.time, java.math. Ce chapitre est une visite guidée — à quoi sert chacun, les classes principales qu'il contient, et quand l'utiliser plutôt que ses voisins.

`java.lang` — le package que vous n'importez jamais

java.lang est importé automatiquement dans chaque fichier source. Tout ce qu'il contient est accessible par son simple nom, sans aucune ligne import :

Object, Class, String, StringBuilder — les types que tout programme utilise.
Math — sqrt, min, max, random, les fonctions trigonométriques.
Types enveloppes — Integer, Long, Double, Boolean, Character, Byte, Short.
Thread, Runnable, ThreadLocal — les primitives de concurrence d'origine.
System — out, err, currentTimeMillis(), getenv, exit.
Throwable, Exception, RuntimeException, Error — toute la hiérarchie des exceptions.
Iterable, Comparable, CharSequence, AutoCloseable — les interfaces sur lesquelles le langage lui-même s'appuie pour for-each, les génériques, try-with-resources et autres.

Si vous voyez une classe utilisée sans import, elle provient presque toujours d'ici.

`java.util` — collections, utilitaires et les anciennes classes de date

java.util est le package du quotidien. Le framework de collections à lui seul suffit à justifier de le connaître.

Interfaces de collection : Collection, List, Set, Map, Queue, Deque.
Implémentations concrètes : ArrayList, LinkedList, HashMap, LinkedHashMap, TreeMap, HashSet, TreeSet, ArrayDeque.
Classes utilitaires : Arrays (méthodes sur les tableaux), Collections (sort, unmodifiableList, ...), Objects (requireNonNull, hash).
Optional — pour les types de retour qui « n'ont peut-être pas de valeur ».
Random, Scanner, UUID — des utilitaires courants que vous rencontrerez partout.
Les anciennes classes de date — Date, Calendar, TimeZone. Ne les utilisez pas dans du nouveau code ; utilisez plutôt java.time.

java.util possède également des sous-packages importants à connaître :

java.util.concurrent — ConcurrentHashMap, ExecutorService, Future, CompletableFuture, la boîte à outils de concurrence moderne.
java.util.stream — l'API Stream pour les pipelines de style fonctionnel.
java.util.function — les interfaces fonctionnelles : Function, Predicate, Supplier, Consumer, la famille utilisée par les streams et les lambdas.

`java.io` — les flux classiques

Le package I/O d'origine, encore largement utilisé partout, même si java.nio est désormais préféré pour le nouveau code.

Flux d'octets : InputStream, OutputStream, FileInputStream, FileOutputStream, BufferedInputStream, ByteArrayInputStream.
Flux de caractères : Reader, Writer, FileReader, FileWriter, BufferedReader, InputStreamReader, PrintWriter.
File — l'abstraction legacy du système de fichiers.
Sérialisation : Serializable, ObjectInputStream, ObjectOutputStream.

La séparation entre les flux d'octets (InputStream/OutputStream) et les flux de caractères (Reader/Writer) est intentionnelle — les octets pour les données binaires, les caractères pour le texte avec un encodage connu.

`java.nio` — I/O moderne et chemins de fichiers

« NIO » signifiait à l'origine « new I/O » ; aujourd'hui c'est simplement le package I/O recommandé.

java.nio.file.Path — le remplaçant moderne de java.io.File.
java.nio.file.Files — des helpers en une ligne : Files.readString, Files.write, Files.walk, Files.exists.
java.nio.file.Paths — l'ancien point d'entrée ; Path.of(...) fait la même chose en moins de code.
Buffers et canaux : ByteBuffer, FileChannel, SocketChannel — des blocs de construction bas niveau pour l'I/O haute performance.

Pour lire un fichier dans du nouveau code, utilisez Files.readString(Path.of(...)) plutôt qu'un BufferedReader associé à un try-with-resources.

`java.net` — réseau

URLs, sockets et HTTP.

URL, URI — analyse et représentation des adresses.
Socket, ServerSocket, DatagramSocket — TCP et UDP bas niveau.
InetAddress — adresses IP et résolution de noms d'hôtes.

Java 11 a ajouté java.net.http.HttpClient, un client HTTP moderne avec support asynchrone intégré au JDK. Pour le nouveau code effectuant des requêtes HTTP, c'est le bon point de départ — aucune bibliothèque tierce n'est requise.

`java.time` — dates et heures bien gérées

Ajouté dans Java 8 pour remplacer l'API Date / Calendar défaillante.

LocalDate, LocalTime, LocalDateTime — valeurs d'horloge murale, sans fuseau horaire.
ZonedDateTime, ZoneId — instants avec fuseau horaire.
Instant — un point sur la ligne de temps globale ; le type à stocker en base de données.
Duration, Period — des quantités de temps (secondes vs. jours/mois).
DateTimeFormatter — analyse et formatage.

Tous les types java.time sont immuables et thread-safe. Cela seul suffit à justifier la migration de tout code utilisant encore java.util.Date.

`java.math` — arithmétique de précision

Quand double et long ne suffisent pas :

BigInteger — entiers de précision arbitraire ; pas de débordement.
BigDecimal — arithmétique décimale exacte avec un mode d'arrondi explicite ; ce qu'il faut pour l'argent.

MathContext et RoundingMode complètent le package.

Quelques autres que vous rencontrerez

java.text — formatage plus ancien (NumberFormat, MessageFormat). Largement remplacé par java.time et String.format, mais encore courant pour la sortie localisée.
java.security — hachage, signature ; MessageDigest, KeyStore, Signature.
javax.crypto — chiffrement symétrique et asymétrique.
java.sql — API JDBC.
javax.xml, org.w3c.dom, org.xml.sax — analyse XML.

Les préfixes javax.* et org.* sont historiques — javax était à l'origine pour les « extensions », et les packages org.* provenaient d'organismes de normalisation. Aujourd'hui, ce sont des packages JDK ordinaires comme les autres.

Un exemple concret

Ce programme utilise java.util, java.util.stream, java.time et java.math en un seul endroit — un aperçu de la façon dont la bibliothèque standard se compose.

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

Le résultat affiché est :

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

Notez que les totaux sont exacts (BigDecimal n'a pas perdu un centime), les jours sont groupés dans l'ordre calendaire (le fournisseur TreeMap les a triés), et l'écart entre les dates est calculé sans un seul calcul manuel en millisecondes. Le même programme serait deux fois plus long et moins lisible avec les équivalents Date/Calendar d'avant Java 8 et double pour les montants. Choisir le bon package, c'est déjà la moitié du travail.

Et ensuite

Vous avez maintenant vu ce que contient la bibliothèque standard. La dernière pièce de l'histoire des packages est la façon dont la JVM trouve réellement toutes ces classes — les vôtres et celles du JDK — à la compilation et à l'exécution. Continuez vers le classpath Java.

Pratique

Un nouveau projet Java doit gérer des prix et des dates. Quels packages utiliser ?

`java.math.BigDecimal` pour l'argent et `java.time` (par exemple `LocalDate`, `DateTimeFormatter`) pour les dates — tous deux sont conçus pour cela et évitent les bugs d'arrondi de `double` et la mutabilité des classes legacy `Date`/`Calendar``double` pour l'argent et `java.util.Date` avec `java.text.SimpleDateFormat` pour les dates — ce sont les choix standard du JDK`java.lang.Number` pour l'argent et `java.util.Calendar` pour les dates — tous deux sont immuables et thread-safeToujours utiliser des bibliothèques tierces (Joda-Time, JodaMoney) car le JDK ne fournit rien d'adapté

java.lang — le package que vous n'importez jamais

java.util — collections, utilitaires et les anciennes classes de date

java.io — les flux classiques

java.nio — I/O moderne et chemins de fichiers

java.net — réseau

java.time — dates et heures bien gérées

java.math — arithmétique de précision