Java 25 (LTS) — Guia das Principais Novidades

// Antes do Java 25
Object value = getValueFromAPI();
if (value instanceof Integer) {
    Integer i = (Integer) value;
    System.out.println("Valor: " + i);
}

// Java 25 - Direto com primitivos
if (value instanceof int i) {
    System.out.println("Valor: " + i);  // i já é int, não Integer
}

// Switch aprimorado
Object processValue(Object value) {
    return switch (value) {
        case int i when i > 0    -> "Positivo: " + i;
        case int i               -> "Negativo ou zero: " + i;
        case double d            -> "Decimal: " + d;
        case String s            -> "Texto: " + s;
        case null                -> "Valor nulo";
        default                  -> "Tipo não suportado";
    };
}

Object num = 42;
switch (num) {
    case byte b -> // Funciona! 42 cabe em byte (-128 a 127)
        System.out.println("Byte: " + b);
}

Object big = 1000;
switch (big) {
    case byte b -> // Não executa - 1000 > 127
        System.out.println("Byte: " + b);
    case int i ->  // Este caso executa
        System.out.println("Int: " + i);
}

// Antes - arquivo cheio de imports
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.stream.Stream;
import java.util.stream.Collectors;
// ... pode chegar a 50+ imports

// Java 25 - um único import de módulo
import module java.base;

public class DataProcessor {
    // Todas as classes de java.base disponíveis
    Map<String, List<String>> processData(List<String> items) {
        return items.stream()
            .collect(Collectors.groupingBy(s -> s.substring(0, 1)));
    }
}

import module java.base;     // contém java.util.List
import module java.desktop;  // contém java.awt.List

// Resolver ambiguidade com import específico
import java.util.List;  // Este "ganha"

List<String> strings = new ArrayList<>();  // usa java.util.List

// HelloWorld.java - Sem class, sem public static!
void main() {
    println("Hello, World!");  // println já importado
}

// Pode adicionar métodos e campos
String nome = "Java 25";
int versao = 25;

void main() {
    println("Bem-vindo ao " + nome);
    mostrarInfo();
}

void mostrarInfo() {
    println("Versão: " + versao);
    var entrada = readln("Digite algo: ");  // readln também disponível
    println("Você digitou: " + entrada);
}

// Antes do Java 25 - limitado
class Employee extends Person {
    public Employee(String name, int age, String dept) {
        super(name, age);  // DEVE ser primeiro
        // Validação só depois - tarde demais se super() falhar
        if (age < 18) {
            throw new IllegalArgumentException("Menor de idade");
        }
    }
}

// Java 25 - flexível e seguro
class Employee extends Person {
    private final String department;

    public Employee(String name, int age, String dept) {
        // Validar ANTES de construir
        Objects.requireNonNull(name, "Nome obrigatório");
        if (age < 18) {
            throw new IllegalArgumentException("Menor de idade");
        }

        // Preparar dados
        var normalizedName = name.trim().toUpperCase();

        // Agora sim, construir
        super(normalizedName, age);
        this.department = dept;
    }
}

// Declaração
public class SecurityContext {
    static final ScopedValue<User> CURRENT_USER = ScopedValue.newInstance();

    // Uso - valor existe apenas dentro do escopo
    public void processRequest(User user, Runnable task) {
        ScopedValue.where(CURRENT_USER, user)
            .run(task);  // user disponível durante task
        // user automaticamente removido aqui
    }

    // Acesso em qualquer ponto do call stack
    public static void checkPermission(String resource) {
        User user = CURRENT_USER.get();
        if (user == null || !user.hasPermission(resource)) {
            throw new AccessDeniedException();
        }
    }
}

// Exemplo básico - buscar dados em paralelo
public UserProfile getUserProfile(Long userId) throws Exception {
    try (var scope = StructuredTaskScope.open()) {
        // Lançar tarefas paralelas
        var userTask = scope.fork(() -> userService.findUser(userId));
        var ordersTask = scope.fork(() -> orderService.findOrders(userId));
        var prefsTask = scope.fork(() -> prefsService.findPreferences(userId));

        // Aguardar todas completarem
        scope.join();

        // Obter resultados - garantido sem exceções perdidas
        return new UserProfile(
            userTask.get(),
            ordersTask.get(),
            prefsTask.get()
        );
    }
    // Qualquer tarefa não finalizada é cancelada automaticamente
}

// ShutdownOnFailure - cancela todas se uma falhar
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    var task1 = scope.fork(() -> riskyOperation1());
    var task2 = scope.fork(() -> riskyOperation2());

    scope.join()
         .throwIfFailed();  // Lança exceção se alguma falhou

    // Só chega aqui se AMBAS tiveram sucesso
    processResults(task1.get(), task2.get());
}

// ShutdownOnSuccess - retorna o primeiro que completar
try (var scope = new StructuredTaskScope.ShutdownOnSuccess<String>()) {
    scope.fork(() -> slowDatabase.query());
    scope.fork(() -> fastCache.get());
    scope.fork(() -> mediumSpeedAPI.fetch());

    scope.join();

    return scope.result();  // Retorna o mais rápido
}

public class ConfigManager {
    // Valor estável - inicializado uma vez quando necessário
    private final StableValue<Configuration> config = StableValue.of();

    public Configuration getConfig() {
        // Inicializa na primeira chamada, retorna o mesmo nas próximas
        return config.orElseSet(() -> {
            // Código de inicialização executado apenas uma vez
            return loadConfigFromFile();
        });
    }
}

// Uso em singleton thread-safe
public class DatabaseConnection {
    private static final StableValue<DatabaseConnection> INSTANCE = StableValue.of();

    public static DatabaseConnection getInstance() {
        return INSTANCE.orElseSet(DatabaseConnection::new);
    }
}

// Exemplo: Multiplicar dois arrays
public void multiplyArrays(float[] a, float[] b, float[] result) {
    var species = FloatVector.SPECIES_PREFERRED;

    // Loop vetorizado - processa vários elementos por vez
    int i = 0;
    for (; i < species.loopBound(a.length); i += species.length()) {
        FloatVector va = FloatVector.fromArray(species, a, i);
        FloatVector vb = FloatVector.fromArray(species, b, i);
        va.mul(vb).intoArray(result, i);
    }

    // Processar elementos restantes
    for (; i < a.length; i++) {
        result[i] = a[i] * b[i];
    }
}

// Criar hash seguro de senha
public byte[] hashPassword(String password, byte[] salt)
        throws GeneralSecurityException {

    SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256");

    PBEKeySpec spec = new PBEKeySpec(
        password.toCharArray(),
        salt,
        120_000,  // iterações (OWASP 2024)
        256       // bits de saída
    );

    SecretKey key = factory.generateSecret(spec);
    return key.getEncoded();
}

// Verificar senha
public boolean verifyPassword(String password, byte[] salt, byte[] hash)
        throws GeneralSecurityException {

    byte[] calculatedHash = hashPassword(password, salt);
    return MessageDigest.isEqual(calculatedHash, hash);  // Comparação segura
}

// Carregar certificado PEM
CertificateFactory cf = CertificateFactory.getInstance("X.509");
try (var input = Files.newInputStream(Path.of("server.crt"))) {
    X509Certificate cert = (X509Certificate) cf.generateCertificate(input);
}

// Carregar chave privada
KeyFactory kf = KeyFactory.getInstance("RSA");
String pemKey = Files.readString(Path.of("server.key"));
byte[] keyBytes = PEMDecoder.decode(pemKey);  // Nova API
PrivateKey privateKey = kf.generatePrivate(new PKCS8EncodedKeySpec(keyBytes));