# Da Verbosidade à Elegância

## Introdução

O Java evoluiu ao longo das últimas décadas de uma linguagem fortemente orientada a objetos para uma plataforma moderna, 
que incorpora paradigmas funcionais, imutáveis e concorrência leve. Este artigo explora a evolução dos paradigmas 
de programação do Java, da versão 1.5 até a 21, com exemplos práticos.

---

## Java 1.5 (2004): Generics e Anotações

**Paradigma dominante:** Orientação a Objetos com Generics

### 🧩 Recursos:
- Generics (`List<String>`)
- Anotações (`@Override`)
- Auto-boxing/unboxing
- Enhanced for

```java
List<String> nomes = new ArrayList<>();
nomes.add("Ana");
for (String nome : nomes) {
    System.out.println(nome);
}
```

---

## Java 8 (2014): Paradigma Funcional

**Paradigma dominante:** Programação funcional e declarativa

### 🧩 Recursos:
- Lambdas
- Stream API
- Optional<T>
- Interfaces funcionais (`Function`, `Predicate`)

```java
List<String> nomes = List.of("Ana", "Carlos", "Beatriz");
nomes.stream()
     .filter(n -> n.startsWith("B"))
     .forEach(System.out::println);
```

---

## Java 9–14: Modularização e Sintaxe Moderna

**Paradigma dominante:** Modularização e concisão

### 🧩 Recursos:
- Módulos (`module-info.java`)
- `var` (Java 10)
- `switch` como expressão

```java
var nome = "Java";
System.out.println("Bem-vindo, " + nome);
```

```java
String resultado = switch (dia) {
    case "SEGUNDA" -> "Início da semana";
    case "SEXTA" -> "Sextou!";
    default -> "Dia comum";
};
```

---

## Java 16–17: Imutabilidade e Segurança

**Paradigma dominante:** Programação orientada a dados e segurança de tipos

### 🧩 Recursos:
- `record`
- `sealed` classes

```java
public record Pessoa(String nome, int idade) {}

Pessoa p = new Pessoa("João", 30);
System.out.println(p.nome());
```

```java
public sealed class Forma permits Circulo, Quadrado {}
```

---

## Java 19–21: Concorrência Leve com Threads Virtuais

**Paradigma dominante:** Concorrência estruturada e leve

### 🧩 Recursos:
- Threads virtuais (Project Loom)
- Pattern Matching aprimorado

```java
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    IntStream.range(0, 10).forEach(i ->
        executor.submit(() -> {
            Thread.sleep(1000);
            System.out.println("Executando tarefa " + i);
        })
    );
}
```

---

## Comparativo de Paradigmas

| Versão | Paradigma Central                | Destaques                                |
|--------|----------------------------------|------------------------------------------|
| 1.5    | OO com Generics                  | Tipagem segura, início de anotações      |
| 8      | Funcional                        | Lambdas, Stream API                      |
| 10+    | Conciso                          | `var`, `switch` moderno                  |
| 17     | Imutável e seguro                | `record`, `sealed`                       |
| 21     | Concorrência leve                | Threads virtuais                         |

---

## Conclusão

A linguagem Java evoluiu sem perder sua base. De generics à concorrência leve, o Java 21 mostra como uma linguagem pode continuar relevante por décadas — modernizando paradigmas e mantendo compatibilidade.