O quão difícil é um Hello World em Java?

Se você já mexeu com java imaginou esse código aqui certo?

public class Main {
    public static void main (String[] args) {
        System.out.println("Hello world!");
    }
}

E se eu te disser que esse segundo código faz a mesma coisa:

void main() {
    System.out.println("Hello world!");
}

Sim, essa estrutura é do recurso unnamed classes, inserido como preview no java 21, mas acredito que para próxima release LTS isso já pode estar habilitado!🤞🏻

Mas ai você pode argumentar que para executar esse arquivo você precisaria da JRE, configurar o java nas variáveis de ambiente e toda a parafernalha necessária para rodar um bytecode java em cada máquina onde for executar esse algoritmo.

Não é bem assim, a algum tempo foi criada a GraalVM, que trás o conceito de compilar o seu arquivo java para um binário nativo da máquina em que foi criado, ou seja, a partir deste momento você tem um binário executável na arquitetura + SO em que foi compilado.

O ponto negativo é claro, fica com relação a instalar os SDKs de cada SO para compilar nativo, em Linux Ubuntu é só um "sudo apt-get install build-essential libz-dev zlib1g-dev" enquanto no Windows tem que instalar o Visual Studio com o pacote de Desktop development with C++ e marcar a opção de Windows SDK relativo a sua versão (11, 10, …), reserve por volta de 20GB no Windows 🥲.

A vantagem é que uma vez compilado você pode passar para qualquer outro computador com o mesmo SO e arquitetura que vai funcionar! Muito massa! Já pode compartilhar com seus colegas seu hello world executável em java!

Mão na massa!

Os passos são bem simples, basta compilar o seu .java com o javac como sempre foi, com o seguinte comando:

javac --enable-preview -source 21 Main.java

obs.: - enabled-preview -source 21 somente é necessário se for usar o recurso unnamed classes.
Em seguida usar o novo comando native- image para compilar:

native-image --enable-preview Main

se tudo ocorrer com sucesso, será criado um novo binário executável main.exe ou main se estiver no linux.

Para executar basta digitar o seguinte comando no terminal:

./main.exe

E pronto! Já é possível ver o seu "Hello World!" Aparecendo no terminal.
Este é o uso mais simples de compilação nativa do java usando como base um .class, mas também existe a compilação para um .jar, neste caso o comando é:

native-image -jar Main.jar myExecutableName

Se tudo ocorrer com sucesso será criado um executável com o nome myExecutableName.exe ou myExecutableName em linux.

Conclusão

Entre os principais ganhos em compilar nativo está a diminuição no tempo de inicialização e um menor consumo de recursos para executar seu algoritmo, em contraparte perdemos as otimizações que a JVM faz ao longo do cíclo de vida de uma aplicação, temos um garbage collector mais enxuto, ocorre um aumento no tempo de compilação e se torna necessário compilar para cada arquitetura onde o algoritmo será executado.
Por hoje é só pessoal! Se chegou até aqui muito obrigado!

Fontes:

https://openjdk.org/jeps/445
https://www.graalvm.org/latest/reference-manual/native-image/
https://www.graalvm.org/latest/docs/getting-started/

Comments

[Wellington Domiciano]

Eu amo essa feature, pois acredito que ajudará a diminuir o "medo" dos iniciantes, tornando a linguagem mais amigável. E, de quebra, ainda facilita quando a gente estiver testando ou prototipando ideias.

---

mas acredito que para proxima release isso já pode estar habilitado!🤞🏻

Infelizmente não. O apanhado features do JDK 22 já está fechado.

Ele virá com o segundo preview dessa feature que, inclusive, mudou de nome.

De Unnamed Classes passou a se chamar Implicitly Declared Classes segundo a JEP 463.

Não vejo a hora de chegar na versão final.