Java: O Gigante Empresarial

Java é uma das linguagens de programação mais estabelecidas e influentes do mundo. Lançada pela Sun Microsystems em 1995, Java se tornou sinônimo de desenvolvimento empresarial robusto, com sua filosofia “Write Once, Run Anywhere” e a poderosa Java Virtual Machine (JVM).

Por que Java? Java alimenta bilhões de dispositivos, desde servidores empresariais até smartphones Android. Frameworks como Spring Boot tornaram o desenvolvimento moderno com Java mais produtivo do que nunca.

Recursos Modernos (Java 17+)

1. Records - Classes de dados imutáveis concisas
2. Sealed Classes - Hierarquias de tipos controladas
3. Pattern Matching - Switch expressions expressivas
4. Text Blocks - Strings multilinhas
5. Virtual Threads - Concorrência leve e escalável
6. Var Keyword - Inferência de tipo local

Fundamentos

Tipos e Variáveis

// Tipos primitivos
String nome = "Maria";
int idade = 25;
double altura = 1.68;
boolean ativo = true;
char inicial = 'M';
long populacao = 8_000_000_000L;

// Inferência de tipo (Java 10+)
var email = "[email protected]";
var lista = new ArrayList<Integer>();

// Wrappers e autoboxing
Integer numero = 42;           // Autoboxing
int primitivo = numero;        // Unboxing

// Arrays
int[] numeros = {1, 2, 3, 4, 5};
String[][] matriz = {{"a", "b"}, {"c", "d"}};

// Collections
List<String> frutas = new ArrayList<>();
frutas.add("maçã");
frutas.add("banana");

Map<String, Integer> usuarios = new HashMap<>();
usuarios.put("alice", 25);
usuarios.put("bob", 30);

Set<String> tags = new HashSet<>(Set.of("java", "spring", "backend"));

Classes e Objetos

import java.time.LocalDateTime;

// Classe tradicional
public class Usuario {
    private final int id;
    private String nome;
    private final String email;
    private final LocalDateTime criadoEm;
    
    // Construtor
    public Usuario(int id, String nome, String email) {
        this.id = id;
        this.nome = nome;
        this.email = email;
        this.criadoEm = LocalDateTime.now();
    }
    
    // Getters e Setters
    public int getId() { return id; }
    public String getNome() { return nome; }
    public void setNome(String nome) { this.nome = nome; }
    public String getEmail() { return email; }
    
    // Método
    public String saudar() {
        return String.format("Olá, %s!", nome);
    }
    
    @Override
    public String toString() {
        return "Usuario{id=%d, nome='%s', email='%s'}".formatted(id, nome, email);
    }
}

// Record (Java 14+) - imutável e conciso
public record Produto(String nome, double preco, int quantidade) {
    // Compact constructor para validação
    public Produto {
        if (preco < 0) throw new IllegalArgumentException("Preço deve ser positivo");
    }
    
    // Método adicional
    public double valorTotal() {
        return preco * quantidade;
    }
}

// Classe selada (Java 17+)
public sealed abstract class Forma permits Retangulo, Circulo, Triangulo {
    public abstract double area();
}

public final class Retangulo extends Forma {
    private final double largura;
    private final double altura;
    
    public Retangulo(double largura, double altura) {
        this.largura = largura;
        this.altura = altura;
    }
    
    @Override
    public double area() {
        return largura * altura;
    }
}

Interfaces e Generics

import java.util.Optional;
import java.util.List;

// Interface genérica
public interface Repositorio<T, ID> {
    Optional<T> buscarPorId(ID id);
    List<T> listarTodos();
    T salvar(T entidade);
    void deletar(ID id);
}

// Interface funcional
@FunctionalInterface
public interface Validador<T> {
    boolean validar(T item);
    
    // Método default
    default Validador<T> e(Validador<T> outro) {
        return item -> this.validar(item) && outro.validar(item);
    }
}

// Implementação
public class UsuarioRepositorio implements Repositorio<Usuario, Integer> {
    private final List<Usuario> usuarios = new ArrayList<>();
    
    @Override
    public Optional<Usuario> buscarPorId(Integer id) {
        return usuarios.stream()
            .filter(u -> u.getId() == id)
            .findFirst();
    }
    
    @Override
    public List<Usuario> listarTodos() {
        return List.copyOf(usuarios);
    }
    
    @Override
    public Usuario salvar(Usuario entidade) {
        usuarios.add(entidade);
        return entidade;
    }
    
    @Override
    public void deletar(Integer id) {
        usuarios.removeIf(u -> u.getId() == id);
    }
}

Streams e Lambdas

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class StreamsExemplo {
    public void demonstrar() {
        var produtos = List.of(
            new Produto("Laptop", 3500, 2),
            new Produto("Mouse", 150, 10),
            new Produto("Teclado", 300, 5),
            new Produto("Monitor", 1200, 3)
        );
        
        // Filtrar e ordenar
        var caros = produtos.stream()
            .filter(p -> p.preco() > 500)
            .sorted((a, b) -> Double.compare(b.preco(), a.preco()))
            .toList();
        
        // Map para transformar
        var nomes = produtos.stream()
            .map(Produto::nome)
            .collect(Collectors.toList());
        
        // Reduce para agregar
        var total = produtos.stream()
            .mapToDouble(Produto::valorTotal)
            .sum();
        
        // Grouping
        Map<String, List<Produto>> porCategoria = produtos.stream()
            .collect(Collectors.groupingBy(p -> 
                p.preco() > 1000 ? "Premium" : "Standard"
            ));
        
        // Partitioning
        var particionado = produtos.stream()
            .collect(Collectors.partitioningBy(p -> p.preco() > 500));
        
        // FlatMap
        var todosOsNomes = List.of(
            List.of("Ana", "Bruno"),
            List.of("Carlos", "Diana")
        ).stream()
            .flatMap(List::stream)
            .toList();
    }
}

Pattern Matching (Java 21+)

// Switch expression com pattern matching
public String descrever(Object obj) {
    return switch (obj) {
        case null -> "Nulo";
        case String s when s.isEmpty() -> "String vazia";
        case String s -> "String: " + s;
        case Integer i when i > 0 -> "Inteiro positivo: " + i;
        case Integer i -> "Inteiro: " + i;
        case List<?> list -> "Lista com %d elementos".formatted(list.size());
        default -> "Objeto: " + obj.getClass().getSimpleName();
    };
}

// Record patterns
record Ponto(int x, int y) {}
record Linha(Ponto inicio, Ponto fim) {}

public String analisarLinha(Linha linha) {
    return switch (linha) {
        case Linha(Ponto(var x1, var y1), Ponto(var x2, var y2)) 
            when x1 == x2 -> "Linha vertical";
        case Linha(Ponto(var x1, var y1), Ponto(var x2, var y2)) 
            when y1 == y2 -> "Linha horizontal";
        case Linha l -> "Linha diagonal";
    };
}

Virtual Threads (Java 21+)

import java.util.concurrent.*;
import java.time.Duration;

public class VirtualThreadsExemplo {
    public void demonstrarVirtualThreads() throws Exception {
        // Thread virtual simples
        Thread.startVirtualThread(() -> {
            System.out.println("Hello from virtual thread!");
        });
        
        // Executor com virtual threads
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            List<Future<String>> futures = new ArrayList<>();
            
            for (int i = 0; i < 10_000; i++) {
                final int id = i;
                futures.add(executor.submit(() -> {
                    Thread.sleep(Duration.ofMillis(100));
                    return "Resultado " + id;
                }));
            }
            
            for (var future : futures) {
                System.out.println(future.get());
            }
        }
        
        // Structured Concurrency (preview)
        // try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
        //     Future<String> user = scope.fork(() -> buscarUsuario());
        //     Future<List<Pedido>> orders = scope.fork(() -> buscarPedidos());
        //     
        //     scope.join();
        //     scope.throwIfFailed();
        //     
        //     return new Response(user.resultNow(), orders.resultNow());
        // }
    }
}

Ferramentas Essenciais

Ferramenta	Propósito
Maven	Gerenciamento de dependências e build
Gradle	Build moderno e flexível
Spring Boot	Framework para aplicações
JUnit 5	Testes unitários
IntelliJ IDEA	IDE mais popular

Checklist de Aprendizado

• Dominar OOP e coleções
• Aprender Streams e lambdas
• Estudar generics avançados
• Explorar features do Java 17+
• Praticar com Spring Boot
• Entender JPA/Hibernate
• Construir uma API REST

Recursos Essenciais

• Java Documentation
• Baeldung
• Spring Guides
• JetBrains Academy

Citação

“Java continua sendo uma das linguagens mais robustas e confiáveis para sistemas empresariais.” - Josh Long

---

Java é a escolha certa para sistemas que precisam de robustez, escalabilidade e manutenibilidade a longo prazo!