Java A Biblioteca Padrão

Quando você instala o JDK, não recebe só o compilador: vem junto uma biblioteca com milhares de classes prontas, para texto, listas, datas, arquivos, contas com dinheiro, internet e muito mais. Ela se chama biblioteca padrão ou API do Java. Ninguém decora essa biblioteca. O que todo programador sabe é onde procurar: em que pacote fica cada assunto e como ler a documentação. É isso que esta aula ensina.

Esta aula continua a anterior, Pacotes e import: lá você aprendeu o que é um pacote; aqui você conhece os pacotes que já vêm com o Java.

A ideia: uma caixa de ferramentas que vem com o JDK

Imagine que a Ana comprou uma casa e, junto com a chave, ganhou uma oficina completa: martelo, chaves de fenda, furadeira, trena, tudo organizado em gavetas com etiqueta. Ela não precisa fabricar um martelo para pendurar um quadro; precisa saber em que gaveta ele está.

A biblioteca padrão é essa oficina. As gavetas são os pacotes (java.util, java.time…), as ferramentas são as classes (ArrayList, LocalDate…) e o manual é o Javadoc.

API é a sigla de Application Programming Interface, "interface de programação de aplicações": o conjunto de classes e métodos que alguém deixou pronto para outros programadores usarem. "A API do Java" é a biblioteca padrão; "a API do JUnit" é a biblioteca do JUnit; e assim por diante.

Do tamanho de uma cidade

No Java moderno, os pacotes ficam agrupados em módulos (veja Módulos). O JDK 25 da Ana tem 69 deles:

$ java --list-modules | wc -l
69
$ java --list-modules | head -5
java.base@25.0.4.1
java.compiler@25.0.4.1
java.datatransfer@25.0.4.1
java.desktop@25.0.4.1
java.instrument@25.0.4.1

O --list-modules lista os módulos; o | wc -l conta as linhas, e o | head -5 mostra só as cinco primeiras (recursos do terminal Linux, não do Java). O mais importante é o primeiro: java.base, o módulo básico, que todo programa usa. Quase tudo desta aula está nele.

Os pacotes mais usados

De todos esses pacotes, um punhado aparece em quase todo programa. Esta tabela é para você voltar sempre que precisar:

Um passeio por seis gavetas

Para ver a biblioteca trabalhando, a Ana escreveu um programa que usa uma ferramenta de cada pacote principal. Não se preocupe em entender cada linha agora: cada uma tem uma aula própria. Repare nos import do topo, um para cada classe de fora de java.lang.

import java.math.BigDecimal;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Main {
    public static void main(String[] args) throws Exception {
        // java.lang: sem import
        String nome = "Ana";
        System.out.println(nome.toUpperCase() + " " + Math.max(3, 9));

        // java.util: listas e utilitários
        List<String> frutas = new ArrayList<>(List.of("uva", "maçã", "banana"));
        Collections.sort(frutas);
        System.out.println(frutas);

        // java.time: datas
        LocalDate prova = LocalDate.of(2026, 10, 16);
        System.out.println(prova + " -> " + prova.plusDays(7) + " " + prova.getDayOfWeek());

        // java.math: contas exatas
        System.out.println(0.1 + 0.2);
        System.out.println(new BigDecimal("0.1").add(new BigDecimal("0.2")));

        // java.util.stream: processar coleções
        System.out.println(frutas.stream().filter(f -> f.length() > 3).map(String::toUpperCase).toList());

        // java.nio.file: arquivos
        Path arquivo = Path.of("compras.txt");
        Files.writeString(arquivo, "pão\nleite\n");
        System.out.println(Files.readAllLines(arquivo));
    }
}

$ java Main.java
ANA 9                            « java.lang: String e Math
[banana, maçã, uva]              « java.util: a lista em ordem
2026-10-16 -> 2026-10-23 FRIDAY  « java.time: uma semana depois; 16/10/2026 é sexta
0.30000000000000004              « double: conta com erro de arredondamento
0.3                              « java.math: BigDecimal acerta
[BANANA, MAÇÃ]                   « java.util.stream: só as frutas com mais de 3 letras
[pão, leite]                     « java.nio.file: gravou e leu o arquivo
$ cat compras.txt
pão
leite

O throws Exception no main está ali porque mexer em arquivos pode dar erro (disco cheio, sem permissão), e o Java obriga a declarar isso. Você vai entender o motivo em throw e throws.

public class Main {
    public static void main(String[] args) {
        BigDecimal preco = new BigDecimal("19.90");
        BigDecimal quantidade = new BigDecimal("3");
        BigDecimal total = preco; // troque por preco.multiply(quantidade)
        System.out.println(total);
    }
}

import java.math.BigDecimal;

public class Main {
    public static void main(String[] args) {
        BigDecimal preco = new BigDecimal("19.90");
        BigDecimal quantidade = new BigDecimal("3");
        BigDecimal total = preco.multiply(quantidade);
        System.out.println(total);
    }
}

O manual: a documentação oficial (Javadoc)

Toda classe da biblioteca tem uma página de documentação, escrita pelos próprios autores, em inglês. O conjunto dessas páginas se chama Javadoc (o nome da ferramenta que as gera a partir de comentários no código; você vai usá-la em Javadoc). A documentação do Java 25 fica no site da Oracle:

https://docs.oracle.com/en/java/javase/25/docs/api/

Troque o 25 pela versão que você usa (21, 17…). Na página inicial há uma caixa de busca (Search) no topo: digite o nome da classe, como Math, e escolha java.lang.Math na lista. Ninguém navega pelo índice; todo mundo usa a busca.

As partes de uma página

Toda página de classe tem a mesma estrutura. Usando a de Math como exemplo, de cima para baixo:

1. O endereço: java.base › java.lang › Math, ou seja, módulo, pacote e classe. É daqui que você tira o import (a não ser que seja java.lang).
2. A herança: java.lang.Object → java.lang.Math. Mostra de quem a classe herda (veja Herança).
3. A declaração: public final class Math extends Object. Você já sabe ler: pública, final (não pode ser herdada).
4. Description ("descrição"): o que a classe faz, em texto corrido, às vezes com exemplos. No fim, Since: 1.0 diz em que versão do Java ela apareceu.
5. Field Summary ("resumo dos campos"): os atributos públicos, como PI e E.
6. Constructor Summary ("resumo dos construtores"): como criar objetos. A página de Math não tem essa seção, porque não dá para criar um Math (veja static).
7. Method Summary ("resumo dos métodos"): uma tabela com todos os métodos. É a parte que você mais vai usar.
8. Field Details e Method Details: a explicação completa de cada atributo e de cada método.

Lendo a tabela de métodos

A tabela do Method Summary tem três colunas, e acima dela há abas para filtrar (All Methods, Static Methods, Instance Methods, Concrete Methods…). Uma linha dela fica assim:

Modifier and Type

"Modificador e tipo". static diz que você chama pela classe (Math.sqrt); se não houver static, chama por um objeto (texto.length()). double é o tipo do valor devolvido.

Method

O nome e os parâmetros, com tipos e nomes: sqrt recebe um double.

Description

A primeira frase da explicação. Clique no nome do método para ver o resto.

Com essa linha você já consegue escrever a chamada: double r = Math.sqrt(81);. Repare que max aparece quatro vezes na tabela, uma para cada tipo (int, long, float, double): é a sobrecarga.

Lendo o detalhe de um método

Clicando em sqrt, você chega ao Method Details:

public static double sqrt(double a)

Returns the correctly rounded positive square root of a double value. Special cases:
  • If the argument is NaN or less than zero, then the result is NaN.
  • If the argument is positive infinity, then the result is positive infinity.
  • If the argument is positive zero or negative zero, then the result is the same as the argument.

Parameters:
    a - a value.
Returns:
    the positive square root of a. If the argument is NaN or less than zero, the result is NaN.

A parte que separa quem lê a documentação de quem não lê são os casos especiais. Ali está escrito que a raiz de um número negativo não dá erro: devolve NaN (Not a Number, "não é um número"; veja double e float). Os rótulos que você vai encontrar nos detalhes:

Explorando no terminal

A documentação é ótima, mas às vezes é mais rápido perguntar ao próprio JDK. Há duas ferramentas para isso.

O JShell: completar com Tab

O JShell é o melhor lugar para "brincar" com uma classe nova. Digite o nome da classe, um ponto, o começo do método e aperte Tab: ele mostra as opções. Aperte Tab depois do parêntese e ele mostra a assinatura; aperte de novo e ele mostra a documentação, ali mesmo:

$ jshell
|  Welcome to JShell -- Version 25.0.4.1
|  For an introduction type: /help intro

jshell> Math.s                                   « aqui a Ana apertou Tab
scalb(           signum(          sin(             sinh(
sqrt(            subtractExact(
jshell> Math.sqrt(                                « completou e apertou Tab de novo
Signatures:
double Math.sqrt(double a)

<press tab again to see documentation>
jshell> Math.sqrt(                                « mais um Tab
double Math.sqrt(double a)
Returns the correctly rounded positive square root of a double value.Special
cases:
  * If the argument is NaN or less than zero, then the result is NaN.
  * If the argument is positive infinity, then the result is positive infinity.
  * If the argument is positive zero or negative zero, then the result is the
    same as the argument.
Otherwise, the result is the double value closest to
the true mathematical square root of the argument value.

Parameters:
a - a value.

Returns:
the positive square root of a . If the argument is NaN or less than zero, the
result is NaN.

<press tab again to see all possible completions; total possible completions: 1.407>

Signatures = "assinaturas" (o tipo de retorno, o nome e os parâmetros); press tab again to see documentation = "aperte Tab de novo para ver a documentação". É o mesmo texto do site, sem sair do terminal. Funciona com qualquer coisa: "banana". + Tab mostra todos os métodos de String.

No JShell do Java 25 ainda há uma vantagem: o comando /imports mostra que ele já começa com o módulo java.base inteiro importado. Então LocalDate e BigDecimal funcionam sem import:

$ jshell -q
jshell> /imports
|    import java.base
jshell> LocalDate.of(2026, 10, 16).plusMonths(1)
$1 ==> 2026-11-16
jshell> LocalDate.of(2026, 10, 16).getDayOfWeek()
$2 ==> FRIDAY
jshell> new BigDecimal("19.90").multiply(new BigDecimal("3"))
$3 ==> 59.70
jshell> /exit

O -q (de quiet, "quieto") só esconde a mensagem de boas-vindas. Lembre-se: num arquivo .java comum, os import continuam necessários.

import java.time.LocalDate
LocalDate.of(2026, 12, 25).getDayOfWeek()

O javap: a lista de métodos de uma classe

O javap (de Java + p de print, "imprimir") vem no JDK e mostra o "esqueleto" de uma classe compilada: atributos e métodos, sem o código de dentro. A opção -public mostra só o que é público, que é o que você pode usar:

$ javap -public java.lang.Math | grep " max\| sqrt\| round"
  public static double sqrt(double);
  public static int round(float);
  public static long round(double);
  public static int max(int, int);
  public static long max(long, long);
  public static float max(float, float);
  public static double max(double, double);
$ javap java.time.LocalDate | grep " now\| plusDays\| getDayOfWeek\| of("
  public static java.time.LocalDate now();
  public static java.time.LocalDate now(java.time.ZoneId);
  public static java.time.LocalDate now(java.time.Clock);
  public static java.time.LocalDate of(int, java.time.Month, int);
  public static java.time.LocalDate of(int, int, int);
  public java.time.DayOfWeek getDayOfWeek();
  public java.time.LocalDate plusDays(long);

O grep (do terminal) filtra só as linhas com aqueles nomes; sem ele, a lista de Math passa de cem linhas. Leia cada linha como na tabela do Javadoc: public static int round(float) é um método da classe, que recebe um float e devolve um int. Repare que LocalDate.now() é static (chama pela classe) e getDayOfWeek() não é (chama por uma data). O javap não mostra explicações, só as assinaturas: é uma cola rápida.

Biblioteca padrão × bibliotecas de terceiros

Nem tudo vem no JDK. Testes automáticos (JUnit), leitura de JSON, acesso a bancos específicos, gráficos modernos: isso vem de bibliotecas de terceiros, feitas pela comunidade ou por empresas, que você baixa e acrescenta ao projeto. Quem cuida disso são as ferramentas Maven e Gradle.

A regra de ouro: antes de procurar uma biblioteca de fora (ou de escrever do zero), confira se a biblioteca padrão já resolve. Ela resolve muito mais do que parece.

Quando dá errado

Referência

Exercícios

public class Main {
    public static void main(String[] args) {
        // crie a data e mostre a data 30 dias depois
    }
}

import java.time.LocalDate;

public class Main {
    public static void main(String[] args) {
        LocalDate matricula = LocalDate.of(2026, 10, 16);
        System.out.println(matricula.plusDays(30));
    }
}

Resumo

• O JDK traz uma biblioteca enorme, organizada em módulos e pacotes. O módulo java.base tem o essencial.
• Os pacotes do dia a dia: java.lang (sem import), java.util, java.time, java.nio.file, java.math, java.util.stream.
• A documentação oficial (Javadoc) fica em docs.oracle.com/en/java/javase/25/docs/api/. Use a busca, leia o Method Summary e os detalhes: Parameters, Returns, Throws, Since.
• static na coluna Modifier and Type = chame pela classe; sem static = chame por um objeto.
• No terminal: jshell + Tab mostra métodos, assinaturas e documentação; javap -public lista as assinaturas.
• O que não está no JDK vem de bibliotecas de terceiros, pelo Maven ou Gradle.