Java Instalar no Linux

Para programar em Java no seu computador, você precisa do JDK (o kit com o compilador javac, veja JDK, JRE e JVM). No Linux há três caminhos: pelo gerenciador de pacotes do sistema (o mais fácil), baixando o arquivo do Temurin (o que a máquina do guia usa) ou por uma ferramenta que gerencia versões, o SDKMAN. Nesta aula você faz a instalação, configura o JAVA_HOME e o PATH e confere se deu tudo certo.

Você vai aprender

Instalar o JDK 25 pelo apt (Debian, Ubuntu), pelo dnf (Fedora) e pelo pacman (Arch).
Instalar o Temurin a partir do arquivo .tar.gz em /opt/jdk-25, como na máquina do guia.
O que são JAVA_HOME e PATH e como configurá-los no ~/.bashrc.
Instalar com o SDKMAN e conviver com várias versões (update-alternatives).
Conferir a instalação e resolver javac: comando não encontrado.

As sessões de terminal acontecem na máquina fictícia da Ana, um Ubuntu em português. Comandos com sudo pedem a sua senha (ela não aparece enquanto você digita). Se você ainda não conhece o terminal, não se preocupe: basta copiar os comandos com atenção, um por vez, e comparar com a saída mostrada. Usa Windows ou Mac? Vá para Instalar no Windows e macOS.

Antes: já tem Java aí?

Muitos Linux já vêm com um Java, às vezes só o de rodar programas. Abra o terminal e pergunte as duas versões, uma de cada vez: java -version e javac -version. Compare o que apareceu com a tabela:

O que apareceu	O que quer dizer	O que fazer
As duas mostram `25` (ou mais)	O JDK 25 já está instalado.	Nada: pule para Conferir a instalação.
`java` mostra uma versão, `javac` dá "comando não encontrado"	Só há um JRE.	Instale o JDK (abaixo). Veja também Quando dá errado.
As duas dão "comando não encontrado"	Não há Java nenhum.	Instale o JDK (abaixo).
As duas funcionam, mas com versão menor que 25 (17, 21…)	Há um JDK antigo.	Instale o 25 ao lado; veja Várias versões. Para o Nível 1, o 17 e o 21 quase sempre servem.

Caminho 1: pelo gerenciador de pacotes

Cada família de Linux tem o seu "loja de aplicativos" de terminal, o gerenciador de pacotes. Ele baixa, instala e depois mantém o Java atualizado junto com o resto do sistema. É o caminho mais simples. O que muda é o nome do comando e do pacote:

Sistema	Comando	Observação
Ubuntu 26.04, Debian 13 e derivados (Mint, Pop!_OS…)	`sudo apt install openjdk-25-jdk`	O pacote `openjdk-25-jre` é só o de rodar; o `-headless` é sem a parte gráfica (para servidores).
Fedora	`sudo dnf install java-25-openjdk-devel`	No Fedora, o JDK é o pacote `-devel` ("desenvolvimento"); `java-25-openjdk` sozinho é só o de rodar.
Arch, Manjaro	`sudo pacman -S jdk25-openjdk`	`jdk-openjdk` é sempre a versão mais nova (hoje, o 27, que não é LTS). Para o 25, use `jdk25-openjdk`.

Os nomes acima foram conferidos nos repositórios oficiais em outubro de 2026. Num sistema mais antigo, o 25 pode não existir; procure com apt search openjdk, dnf search openjdk ou pacman -Ss openjdk, ou use o Caminho 2.

No Ubuntu, passo a passo

Primeiro, veja o que o Ubuntu oferece. O apt-cache search procura pacotes pelo nome:

$ apt-cache search --names-only "^openjdk-25-(jdk|jre)"
openjdk-25-jdk - OpenJDK Development Kit (JDK)                           « este: o kit completo
openjdk-25-jdk-headless - OpenJDK Development Kit (JDK) (headless)
openjdk-25-jre - OpenJDK Java runtime, using Hotspot JIT                « só para rodar
openjdk-25-jre-headless - OpenJDK Java runtime, using Hotspot JIT (headless)
openjdk-25-jre-zero - Alternative JVM for OpenJDK, using Zero

E qual versão seria instalada:

$ apt-cache policy openjdk-25-jdk
openjdk-25-jdk:
  Instalado: (nenhum)                « ainda não está instalado
  Candidato: 25.0.4.1+1-1~26.04.4    « a versão que o apt instalaria: Java 25.0.4.1
  Tabela de versão:
     25.0.4.1+1-1~26.04.4 500
        500 http://archive.ubuntu.com/ubuntu resolute-updates/main amd64 Packages
        500 http://security.ubuntu.com/ubuntu resolute-security/main amd64 Packages
     25.0.3~7ea-2 500
        500 http://archive.ubuntu.com/ubuntu resolute/main amd64 Packages

Para instalar, atualize a lista de pacotes e peça o JDK:

sudo: Roda o comando como administrador (instalar programas mexe no sistema todo).
apt: O gerenciador de pacotes do Debian e do Ubuntu.
install: A ação: instalar.
openjdk-25-jdk: O pacote: o JDK 25 do OpenJDK. Ele puxa sozinho o openjdk-25-jre e o openjdk-25-jdk-headless, de que depende.

Saída ilustrativa (a lista de pacotes e os tamanhos variam de computador para computador):

$ sudo apt update
[sudo] senha para ana:                  « digite a sua senha (não aparece nada) e Enter
…                                       « o apt baixa a lista de pacotes atualizada
$ sudo apt install openjdk-25-jdk
…                                       « o apt mostra os pacotes que vai instalar
Continuar? [S/n] S                      « digite S e Enter
…                                       « download e instalação; leva alguns minutos

O apt instala o JDK em /usr/lib/jvm/java-25-openjdk-amd64 e cria atalhos em /usr/bin (pelo sistema de "alternativas", que você vai ver em Várias versões), de modo que java e javac funcionam na hora, sem configurar nada. Pule para Conferir a instalação.

Caminho 2: o arquivo do Temurin em `/opt`

Este é o caminho da máquina do guia. Você baixa o JDK "em pacote" (um arquivo .tar.gz, como um .zip), descompacta numa pasta e avisa o terminal onde ela está. Vantagens: funciona em qualquer Linux, você escolhe a versão exata e pode ter várias lado a lado. Desvantagem: as atualizações não chegam sozinhas; você repete o processo quando sair uma nova.

1. Baixar

No site adoptium.net, escolha Temurin 25 (LTS), sistema Linux, arquitetura x64 (computadores comuns; aarch64 para placas ARM, como o Raspberry Pi), pacote JDK, formato .tar.gz. Baixe também o arquivo de conferência, o checksum (.sha256.txt). Pelo terminal (ilustrativo: o nome do arquivo muda a cada atualização):

$ cd ~/Downloads
$ ls
OpenJDK25U-jdk_x64_linux_hotspot_25.0.4.1_1.tar.gz
OpenJDK25U-jdk_x64_linux_hotspot_25.0.4.1_1.tar.gz.sha256.txt
$ sha256sum -c OpenJDK25U-jdk_x64_linux_hotspot_25.0.4.1_1.tar.gz.sha256.txt
OpenJDK25U-jdk_x64_linux_hotspot_25.0.4.1_1.tar.gz: SUCESSO       « o arquivo chegou inteiro e é o original

O sha256sum -c calcula uma "impressão digital" do arquivo baixado e compara com a publicada pelo Adoptium. SUCESSO quer dizer que são iguais. Se aparecer FALHOU, o download veio corrompido: baixe de novo.

2. Descompactar em `/opt`

A pasta /opt (de optional) é o lugar tradicional do Linux para programas instalados "à mão". Como ela pertence ao administrador, os comandos levam sudo:

sudo tar: O programa que abre arquivos .tar, rodando como administrador.
-xzf: Três opções juntas: x = extrair, z = o arquivo está comprimido com gzip (o .gz), f = o arquivo vem a seguir.
OpenJDK25U-…tar.gz: O arquivo baixado (aperte Tab para completar o nome).
-C /opt: Extrair dentro de /opt (C de change directory).

$ sudo tar -xzf OpenJDK25U-jdk_x64_linux_hotspot_25.0.4.1_1.tar.gz -C /opt
$ ls /opt
jdk-25.0.4.1+1                              « a pasta vem com a versão completa no nome
$ sudo mv /opt/jdk-25.0.4.1+1 /opt/jdk-25   « um nome curto, que não muda nas atualizações

(Etapa ilustrativa: o tar e o mv não mostram nada quando dão certo; o nome da pasta segue o da versão baixada.) Renomear para jdk-25 é um truque: quando sair a atualização 25.0.5, você troca a pasta e todas as configurações continuam valendo.

A partir daqui, tudo é real, na máquina da Ana. O JDK já funciona, desde que você diga o caminho inteiro:

$ ls /opt/jdk-25
bin  conf  include  legal  lib  man  NOTICE  release
$ /opt/jdk-25/bin/java -version
openjdk version "25.0.4.1" 2026-08-18 LTS
OpenJDK Runtime Environment Temurin-25.0.4.1+1 (build 25.0.4.1+1-LTS)
OpenJDK 64-Bit Server VM Temurin-25.0.4.1+1 (build 25.0.4.1+1-LTS, mixed mode, sharing)

3. `JAVA_HOME` e `PATH`: ensinar o caminho ao terminal

Ninguém quer digitar /opt/jdk-25/bin/java toda vez. Duas variáveis de ambiente (anotações que o terminal passa para todos os programas) resolvem:

Variável	O que guarda	Quem usa
`JAVA_HOME`	A pasta do JDK: `/opt/jdk-25` (a "casa" do Java).	Maven, Gradle, IDEs e muitos programas Java, para achar o JDK.
`PATH`	A lista de pastas, separadas por `:`, onde o terminal procura os comandos.	O terminal: quando você digita `javac`, ele procura um arquivo `javac` em cada pasta do `PATH`, na ordem.

Para valerem sempre, as duas linhas vão no fim do arquivo ~/.bashrc, que o Bash lê toda vez que um terminal abre. Você pode abrir o arquivo num editor (nano ~/.bashrc) e colar as linhas no fim, ou acrescentá-las de uma vez com cat >>:

$ cat >> ~/.bashrc <<'FIM'
>
> # Java (Temurin JDK 25)
> export JAVA_HOME=/opt/jdk-25
> export PATH="$JAVA_HOME/bin:$PATH"
> FIM
$ tail -4 ~/.bashrc

# Java (Temurin JDK 25)
export JAVA_HOME=/opt/jdk-25
export PATH="$JAVA_HOME/bin:$PATH"

As duas linhas, parte por parte:

export: Cria a variável e a passa para todos os programas abertos por este terminal.
JAVA_HOME=/opt/jdk-25: A pasta do JDK. Sem espaços em volta do =.
PATH="$JAVA_HOME/bin:$PATH": O novo PATH é /opt/jdk-25/bin, depois :, depois o PATH antigo inteiro. Colocar o JDK na frente garante que ele seja achado antes de qualquer outro Java do sistema.

O ~/.bashrc só é lido quando um terminal abre. Para o terminal atual, peça para lê-lo de novo com source (ou feche e abra o terminal):

$ source ~/.bashrc
$ echo $JAVA_HOME
/opt/jdk-25
$ echo $PATH
/opt/jdk-25/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin    « o JDK em primeiro lugar

Cuidado com o $PATH no fim

Se você escrever export PATH="$JAVA_HOME/bin" (esquecendo o :$PATH), o PATH passa a ter só a pasta do Java, e comandos como ls e nano deixam de ser achados ("comando não encontrado"). Se isso acontecer, abra o arquivo com o caminho completo, /usr/bin/nano ~/.bashrc, corrija a linha e abra um terminal novo.

Conferir a instalação

Seja qual for o caminho, confira três coisas: as versões, de onde vêm os comandos e se um programa compila e roda.

$ java -version
openjdk version "25.0.4.1" 2026-08-18 LTS
OpenJDK Runtime Environment Temurin-25.0.4.1+1 (build 25.0.4.1+1-LTS)
OpenJDK 64-Bit Server VM Temurin-25.0.4.1+1 (build 25.0.4.1+1-LTS, mixed mode, sharing)
$ javac -version
javac 25.0.4.1                          « o compilador existe e é da mesma versão
$ which java javac
/opt/jdk-25/bin/java                    « os dois vêm da mesma pasta
/opt/jdk-25/bin/javac

O which mostra qual arquivo o terminal vai usar para cada comando. Se houver mais de um Java no computador, o type -a lista todos, na ordem de busca; o primeiro é o que vale:

$ type -a java
java é /opt/jdk-25/bin/java             « o primeiro: é este que roda
java é /usr/bin/java                    « um Java do sistema, que fica "escondido" atrás
java é /bin/java

Por fim, o teste de verdade: um programa que compila, roda e conta qual Java está rodando. Crie a pasta ~/java/teste e, dentro dela, o arquivo Teste.java com o editor de sua preferência (veja Editores e IDEs):

public class Teste {
    public static void main(String[] args) {
        System.out.println("O Java está funcionando!");
        System.out.println("Versão: " + System.getProperty("java.version"));
        System.out.println("Fornecedor: " + System.getProperty("java.vendor"));
        System.out.println("Pasta do Java: " + System.getProperty("java.home"));
    }
}

$ cd ~/java/teste
$ javac Teste.java
$ java Teste
O Java está funcionando!
Versão: 25.0.4.1
Fornecedor: Eclipse Adoptium            « o Temurin é feito pela Eclipse Adoptium
Pasta do Java: /opt/jdk-25

O System.getProperty("java.version") pergunta ao próprio Java qual é a versão dele. Se você instalou pelo apt, o fornecedor e a pasta serão outros (Ubuntu e /usr/lib/jvm/java-25-openjdk-amd64). Se apareceu O Java está funcionando!, você está pronto para o resto do guia. Os detalhes de javac e java estão em javac e java.

Enquanto não instala, faça o mesmo teste no editor do guia:

Brinque com o código: clique em Rodar. Depois troque a mensagem por uma sua. O arquivo aqui se chama Teste.java, por isso a classe se chama Teste.

public class Teste {
    public static void main(String[] args) {
        System.out.println("O Java está funcionando!");
    }
}

Caminho 3: SDKMAN

O SDKMAN é um programa que instala e troca versões do Java (e do Maven, do Gradle…) sem sudo, tudo dentro da sua pasta pessoal. É popular entre programadores que precisam de várias versões. Passos ilustrativos (veja as instruções atuais em sdkman.io):

$ curl -s "https://get.sdkman.io" | bash        « instala o SDKMAN
$ source "$HOME/.sdkman/bin/sdkman-init.sh"
$ sdk list java                                 « lista as versões; as do Temurin terminam em -tem
$ sdk install java 25.0.4.1-tem                 « use o identificador que aparecer na lista
$ sdk use java 21.0.12.1-tem                    « troca só neste terminal
$ sdk default java 25.0.4.1-tem                 « escolhe a versão padrão

O SDKMAN cuida sozinho do JAVA_HOME e do PATH. Não misture: se usar o SDKMAN, não acrescente as linhas do Caminho 2 no ~/.bashrc.

Várias versões no mesmo computador

É normal ter mais de um Java: um projeto da empresa pede o 17, o guia usa o 25, um programa antigo exige o 8. A máquina da Ana, por exemplo, tem o Temurin 25 em /opt/jdk-25 e, instalados pelo sistema, o Java 8 e o Java 21 em /usr/lib/jvm. Quem decide qual roda é o primeiro encontrado no PATH.

Forma	Como	Quando usar
Caminho completo	`/usr/lib/jvm/java-21-openjdk-amd64/bin/java -version`	Testar uma vez com outra versão.
Trocar o `JAVA_HOME` no terminal	`export JAVA_HOME=/usr/lib/jvm/java-21-openjdk-amd64` e `export PATH="$JAVA_HOME/bin:$PATH"`	Trabalhar um tempo com outra versão; vale até fechar o terminal.
`update-alternatives`	`sudo update-alternatives --config java`	Debian/Ubuntu, para os Javas instalados pelo `apt`: escolhe o que `/usr/bin/java` aponta.
SDKMAN	`sdk use java …`	Quem troca de versão o tempo todo.

No Debian e no Ubuntu, os Javas do apt se registram nas "alternativas" do sistema. O comando abaixo mostra um menu para escolher (saída ilustrativa, no formato real):

$ sudo update-alternatives --config java
Há 3 escolhas como alternativas de java. (fornecendo /usr/bin/java).

  Seleção    Caminho                                         Prioridade Estado
------------------------------------------------------------
* 0            /usr/lib/jvm/java-25-openjdk-amd64/bin/java      2511      modo automático
  1            /usr/lib/jvm/java-21-openjdk-amd64/bin/java      2111      modo manual
  2            /usr/lib/jvm/java-25-openjdk-amd64/bin/java      2511      modo manual
  3            /usr/lib/jvm/java-8-openjdk-amd64/jre/bin/java   1081      modo manual

Pressione <enter> para manter o padrão[*] ou digite o número da seleção: 1

O * marca o atual. Em "modo automático", vence o de maior prioridade (o mais novo). Digitando 1, o /usr/bin/java passa a ser o Java 21. Faça o mesmo para o compilador com sudo update-alternatives --config javac, senão o java e o javac ficam de versões diferentes.

O PATH vence as alternativas

As alternativas só mexem em /usr/bin/java. Se você colocou /opt/jdk-25/bin na frente do PATH (Caminho 2), o Temurin 25 continua sendo o primeiro, não importa o que o update-alternatives diga. Na dúvida, which java responde.

Quando dá errado

javac: comando não encontrado, mas o java funciona

$ java -version
openjdk version "25.0.4.1" 2026-08-18
OpenJDK Runtime Environment (build 25.0.4.1+1-1-26.04.4-Ubuntu)
OpenJDK 64-Bit Server VM (build 25.0.4.1+1-1-26.04.4-Ubuntu, mixed mode, sharing)
$ javac -version
bash: javac: comando não encontrado
$ ls /usr/lib/jvm/java-25-openjdk-amd64/bin
java  jpackage  keytool  rmiregistry

O que aconteceu: este Ubuntu tem o pacote openjdk-25-jre, o Java de rodar programas. A pasta dele não tem javac. É comum: outro programa instalou o JRE como dependência, ou alguém digitou jre no lugar de jdk.

Como resolver: instale o JDK: sudo apt install openjdk-25-jdk (no Fedora, java-25-openjdk-devel; no Arch, jdk25-openjdk). Em alguns Ubuntu, o próprio terminal sugere o pacote quando você digita um comando que não existe; confira se a sugestão é um -jdk, não um -jre.

Configurei o ~/.bashrc e nada mudou

O que aconteceu: o arquivo só é lido quando um terminal abre. O terminal que já estava aberto continua com o PATH antigo.

Como resolver: source ~/.bashrc ou feche e abra o terminal. Depois, echo $JAVA_HOME deve mostrar /opt/jdk-25. Se continuar vazio, confira com tail ~/.bashrc se as linhas foram mesmo gravadas e se não há espaço em volta do =.

bash: /opt/jdk-25/bin/java: Arquivo ou diretório inexistente

O que aconteceu: o caminho não bate com a pasta extraída. Talvez ela ainda se chame jdk-25.0.4.1+1 (faltou o mv), ou o tar extraiu em outro lugar (faltou o -C /opt).

Como resolver: ls /opt mostra o nome real. Renomeie com sudo mv ou ajuste o JAVA_HOME para o nome que está lá.

cannot execute binary file: Exec format error

O que aconteceu: você baixou o JDK de uma arquitetura diferente da do computador (por exemplo, aarch64 num PC comum, ou x64 num Raspberry Pi). Descubra a sua com uname -m: x86_64 = baixe o x64; aarch64 = baixe o aarch64.

java -version mostra outra versão (8, 17, 21…)

O que aconteceu: outro Java está antes no PATH. Como resolver: type -a java mostra a ordem. Coloque o JDK 25 na frente (Caminho 2) ou escolha-o com update-alternatives.

Referência

Comando	Para que serve
`sudo apt install openjdk-25-jdk`	Instala o JDK 25 no Debian/Ubuntu.
`sudo dnf install java-25-openjdk-devel`	Instala o JDK 25 no Fedora.
`sudo pacman -S jdk25-openjdk`	Instala o JDK 25 no Arch.
`sudo tar -xzf ARQUIVO.tar.gz -C /opt`	Extrai o JDK baixado em `/opt`.
`export JAVA_HOME=/opt/jdk-25`	Diz onde está o JDK (no `~/.bashrc`).
`export PATH="$JAVA_HOME/bin:$PATH"`	Põe os comandos do JDK na frente da busca.
`source ~/.bashrc`	Relê o `~/.bashrc` no terminal atual.
`java -version`, `javac -version`	Confere as versões.
`which java`, `type -a java`	Mostra qual Java o terminal usa.
`sudo update-alternatives --config java`	Escolhe entre os Javas do sistema (Debian/Ubuntu).

Missão: faça o programa de teste mostrar duas linhas, javac: ok e java: ok, uma embaixo da outra. Dica: copie a linha do println e mude o texto.

public class Teste {
    public static void main(String[] args) {
        System.out.println("javac: ok");
    }
}

public class Teste {
    public static void main(String[] args) {
        System.out.println("javac: ok");
        System.out.println("java: ok");
    }
}

Exercícios

1. O pacote certo

Complete o comando para instalar o JDK 25 (não só o JRE) no Ubuntu:

sudo apt install

2. A casa do Java

Complete a linha do ~/.bashrc que diz onde o JDK está, na máquina da Ana:

export JAVA_HOME=

3. Você acrescentou as linhas no ~/.bashrc, mas echo $JAVA_HOME continua vazio no mesmo terminal. Por quê?

O JDK não foi instalado. O ~/.bashrc só é lido quando o terminal abre; falta source ~/.bashrc. O JAVA_HOME só funciona no Windows. Precisa reiniciar o computador.

4. Por que $JAVA_HOME/bin vem antes de $PATH na linha do PATH?

Por ordem alfabética. Porque o terminal lê o PATH de trás para a frente. Não faz diferença. Para que o JDK 25 seja achado antes de outros Javas do sistema.

5. No Arch, qual pacote instala especificamente o JDK 25?

jdk25-openjdk jdk-openjdk jre25-openjdk java-25-openjdk-devel

Resumo

Confira antes: java -version e javac -version. Precisa dos dois.
Pelo sistema: apt install openjdk-25-jdk, dnf install java-25-openjdk-devel, pacman -S jdk25-openjdk. Sem configuração extra.
Pelo arquivo do Temurin: extraia em /opt, renomeie para /opt/jdk-25 e acrescente JAVA_HOME e PATH no ~/.bashrc; depois source ~/.bashrc.
which java e type -a java mostram qual Java está sendo usado; o primeiro do PATH vence.
Várias versões: caminho completo, JAVA_HOME no terminal, update-alternatives ou SDKMAN.
javac: comando não encontrado com o java funcionando = só JRE; instale o pacote -jdk.