O quão difícil é um Hello World em Java?
Tags: java, java21, graalvm, programming
Published: 2024-03-06 03:56:11

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.

![Captura de tela mostrando a saída no terminal após executar o comando native-image — enable-preview Main](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/hnrxdjxbvtmal8uadvkg.png)
Para executar basta digitar o seguinte comando no terminal:

```
./main.exe
```

![Captura de tela mostrando a saída no terminal "Hello World!" após executar ./main.exe](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/iyibl318wc8zp3hkfalo.png)


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/