Pacotes da Biblioteca Padrão do Java

O JDK vem com uma vasta biblioteca padrão, organizada em centenas de pacotes. Nos primeiros meses, você vai recorrer repetidamente aos mesmos poucos: java.lang, java.util, java.io, java.nio, java.net, java.time, java.math. Este capítulo é um tour — para que serve cada um, as classes principais dentro dele, e quando usá-lo em vez de seus vizinhos.

`java.lang` — o pacote que você nunca importa

java.lang é importado automaticamente em todo arquivo-fonte. Tudo dentro dele está disponível pelo nome simples, sem nenhuma linha import:

Object, Class, String, StringBuilder — os tipos que todo programa usa.
Math — sqrt, min, max, random, as funções trigonométricas.
Tipos wrapper — Integer, Long, Double, Boolean, Character, Byte, Short.
Thread, Runnable, ThreadLocal — as primitivas de concorrência originais.
System — out, err, currentTimeMillis(), getenv, exit.
Throwable, Exception, RuntimeException, Error — toda a hierarquia de exceções.
Iterable, Comparable, CharSequence, AutoCloseable — interfaces em que a própria linguagem depende para for-each, generics, try-with-resources e afins.

Se você vê uma classe usada sem um import, ela quase sempre vem daqui.

`java.util` — coleções, utilitários e as antigas classes de data

java.util é o pacote do dia a dia. O framework de coleções por si só já é motivo suficiente para conhecê-lo.

Interfaces de coleção: Collection, List, Set, Map, Queue, Deque.
Implementações concretas: ArrayList, LinkedList, HashMap, LinkedHashMap, TreeMap, HashSet, TreeSet, ArrayDeque.
Classes utilitárias: Arrays (métodos para arrays), Collections (sort, unmodifiableList, ...), Objects (requireNonNull, hash).
Optional — para tipos de retorno que "podem não ter valor".
Random, Scanner, UUID — utilitários comuns que você verá em todo lugar.
As antigas classes de data — Date, Calendar, TimeZone. Não use essas em código novo; use java.time em vez disso.

java.util também tem sub-pacotes importantes que vale conhecer:

java.util.concurrent — ConcurrentHashMap, ExecutorService, Future, CompletableFuture, a caixa de ferramentas moderna de concorrência.
java.util.stream — a API Stream para pipelines de estilo funcional.
java.util.function — interfaces funcionais: Function, Predicate, Supplier, Consumer, a família usada por streams e lambdas.

`java.io` — streams clássicos

O pacote de I/O original, ainda amplamente utilizado, embora java.nio seja agora preferido para código novo.

Byte streams: InputStream, OutputStream, FileInputStream, FileOutputStream, BufferedInputStream, ByteArrayInputStream.
Character streams: Reader, Writer, FileReader, FileWriter, BufferedReader, InputStreamReader, PrintWriter.
File — a abstração legada do sistema de arquivos.
Serialização: Serializable, ObjectInputStream, ObjectOutputStream.

A separação entre byte streams (InputStream/OutputStream) e character streams (Reader/Writer) é intencional — bytes para dados binários, caracteres para texto com codificação conhecida.

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

"NIO" originalmente significava "new I/O"; hoje é simplesmente o pacote de I/O recomendado.

java.nio.file.Path — o substituto moderno para java.io.File.
java.nio.file.Files — helpers diretos: Files.readString, Files.write, Files.walk, Files.exists.
java.nio.file.Paths — ponto de entrada mais antigo; Path.of(...) faz o mesmo com menos código.
Buffers e canais: ByteBuffer, FileChannel, SocketChannel — blocos de construção de nível mais baixo para I/O de alto desempenho.

Para novo código que lê um arquivo: use Files.readString(Path.of(...)), não BufferedReader com try-with-resources.

`java.net` — rede

URLs, sockets e HTTP.

URL, URI — análise e representação de endereços.
Socket, ServerSocket, DatagramSocket — TCP e UDP de baixo nível.
InetAddress — IPs e resolução de nomes de host.

O Java 11 adicionou java.net.http.HttpClient, um cliente HTTP moderno com suporte assíncrono embutido no JDK. Para novo código que faz requisições HTTP, esse é o ponto de partida correto — sem necessidade de biblioteca de terceiros.

`java.time` — datas e horas do jeito certo

Adicionado no Java 8 para substituir a API problemática Date/Calendar.

LocalDate, LocalTime, LocalDateTime — valores de relógio de parede, sem fuso.
ZonedDateTime, ZoneId — momentos com fuso horário.
Instant — um ponto na linha do tempo global; o tipo para armazenar em bancos de dados.
Duration, Period — quantidades de tempo (segundos vs. dias/meses).
DateTimeFormatter — análise e formatação.

Todos os tipos de java.time são imutáveis e thread-safe. Isso por si só é motivo suficiente para migrar qualquer código que ainda use java.util.Date.

`java.math` — aritmética precisa

Quando double e long não são suficientes:

BigInteger — inteiros de precisão arbitrária; sem overflow.
BigDecimal — aritmética decimal exata com modo de arredondamento explícito; o que você quer para dinheiro.

MathContext e RoundingMode completam o pacote.

Alguns outros que você vai encontrar

java.text — formatação mais antiga (NumberFormat, MessageFormat). Amplamente substituída por java.time e String.format, mas ainda comum em saída localizada.
java.security — hash, assinatura; MessageDigest, KeyStore, Signature.
javax.crypto — criptografia simétrica e assimétrica.
java.sql — API JDBC.
javax.xml, org.w3c.dom, org.xml.sax — análise de XML.

Os prefixos javax.* e org.* são históricos — javax era originalmente para "extensões", e os pacotes org.* vieram de organismos de padronização. Hoje são pacotes regulares do JDK como qualquer outro.

Um exemplo prático

Este programa usa java.util, java.util.stream, java.time e java.math em um único lugar — um instantâneo de como a biblioteca padrão se compõe.

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

Ele imprime:

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

Perceba que os totais são exatos (BigDecimal nunca perdeu um centavo), os dias estão agrupados em ordem de calendário (o fornecedor TreeMap os ordenou) e a diferença de datas é calculada sem nenhum cálculo manual de milissegundos. O mesmo programa seria o dobro do tamanho e mais confuso com os equivalentes pré-Java-8 de Date/Calendar e double para dinheiro. Escolher o pacote certo é metade da batalha.

O que vem a seguir

Você já viu o que está dentro da biblioteca padrão. A última peça da história dos pacotes é como a JVM realmente encontra todas essas classes — as suas e as do JDK — em tempo de compilação e execução. Continue para o classpath do Java.

Prática

Um novo projeto Java precisa lidar com preços e datas. Quais pacotes você deve usar?

`java.math.BigDecimal` para dinheiro e `java.time` (por exemplo, `LocalDate`, `DateTimeFormatter`) para datas — ambos foram projetados para isso e evitam os bugs de arredondamento do `double` e a mutabilidade das classes legadas `Date`/`Calendar``double` para dinheiro e `java.util.Date` mais `java.text.SimpleDateFormat` para datas — essas são as opções padrão do JDK`java.lang.Number` para dinheiro e `java.util.Calendar` para datas — ambos são imutáveis e thread-safeSempre use bibliotecas de terceiros (Joda-Time, JodaMoney) porque o JDK não fornece nada adequado

java.lang — o pacote que você nunca importa

java.util — coleções, utilitários e as antigas classes de data

java.io — streams clássicos

java.nio — I/O moderno e caminhos

java.net — rede

java.time — datas e horas do jeito certo

java.math — aritmética precisa