Java 8 (LTS) — A Revolução Funcional

// Antes do Java 8 - Verboso e difícil de ler
List<String> nomes = Arrays.asList("Ana", "João", "Maria", "Pedro");
Collections.sort(nomes, new Comparator<String>() {
    @Override
    public int compare(String a, String b) {
        return a.compareToIgnoreCase(b);
    }
});

// Java 8 - Conciso e claro
Collections.sort(nomes, (a, b) -> a.compareToIgnoreCase(b));

// Ainda mais simples com method reference
Collections.sort(nomes, String::compareToIgnoreCase);

// Exemplos diversos de lambda
Runnable task = () -> System.out.println("Hello World");
Function<String, Integer> stringLength = s -> s.length();
Predicate<String> isEmpty = s -> s.isEmpty();
Consumer<String> printer = System.out::println;

// Sem parâmetros
() -> System.out.println("Hello")

// Um parâmetro
x -> x * 2

// Múltiplos parâmetros
(x, y) -> x + y

// Bloco de código
(x, y) -> {
    int sum = x + y;
    return sum * 2;
}

List<String> nomes = Arrays.asList("ana", "joão", "maria");

// Lambda tradicional
nomes.forEach(nome -> System.out.println(nome));

// Method reference - mais limpo
nomes.forEach(System.out::println);

// Tipos de method references
// 1. Método estático
Function<String, Integer> parser = Integer::parseInt;

// 2. Método de instância de objeto específico
String prefix = "Hello ";
Function<String, String> greeter = prefix::concat;

// 3. Método de instância de objeto arbitrário
Function<String, String> upperCase = String::toUpperCase;

// 4. Constructor reference
Supplier<List<String>> listSupplier = ArrayList::new;
Function<String, StringBuilder> sbCreator = StringBuilder::new;

List<Person> pessoas = Arrays.asList(
    new Person("Ana", 25, "SP"),
    new Person("João", 30, "RJ"),
    new Person("Maria", 35, "SP"),
    new Person("Pedro", 20, "MG")
);

// Exemplo complexo: Pessoas de SP, maiores de 21, ordenadas por idade
List<String> resultado = pessoas.stream()
    .filter(p -> "SP".equals(p.getEstado()))  // Filtrar por estado
    .filter(p -> p.getIdade() > 21)           // Filtrar por idade
    .sorted(Comparator.comparing(Person::getIdade))  // Ordenar
    .map(Person::getNome)                     // Extrair nome
    .collect(Collectors.toList());            // Coletar resultado

// Operações estatísticas
IntSummaryStatistics stats = pessoas.stream()
    .mapToInt(Person::getIdade)
    .summaryStatistics();

System.out.println("Média de idade: " + stats.getAverage());
System.out.println("Idade máxima: " + stats.getMax());

// Processamento paralelo automático
long count = pessoas.parallelStream()
    .filter(p -> p.getIdade() > 25)
    .count();

// ForkJoinPool é usado automaticamente
List<String> processedNames = pessoas.parallelStream()
    .map(p -> heavyProcessing(p.getNome()))
    .collect(Collectors.toList());

// Agrupamento
Map<String, List<Person>> porEstado = pessoas.stream()
    .collect(Collectors.groupingBy(Person::getEstado));

// Particionamento
Map<Boolean, List<Person>> adultos = pessoas.stream()
    .collect(Collectors.partitioningBy(p -> p.getIdade() >= 18));

// String joining
String nomes = pessoas.stream()
    .map(Person::getNome)
    .collect(Collectors.joining(", ", "[", "]"));

public class UserService {
    // Retorno claro: pode ou não ter usuário
    public Optional<User> findUserById(Long id) {
        User user = database.find(id);
        return Optional.ofNullable(user);
    }

    // Uso seguro do Optional
    public String getUserDisplayName(Long id) {
        return findUserById(id)
            .map(User::getName)                    // Se existe, pega nome
            .filter(name -> !name.trim().isEmpty()) // Se não vazio
            .orElse("Usuário Anônimo");            // Valor padrão
    }

    // Operações avançadas
    public void sendNotification(Long userId) {
        findUserById(userId)
            .filter(User::isActive)                // Apenas ativos
            .map(User::getEmail)                   // Pegar email
            .filter(email -> email.contains("@"))  // Validar email
            .ifPresent(this::sendEmail);           // Enviar se válido
    }
}

// Anti-patterns - NÃO faça
// Optional.get() sem verificar - derrota o propósito
// Optional.of(null) - vai lançar exceção
// if (optional.isPresent()) { optional.get() } - use ifPresent()

Optional<String> opt = Optional.of("Hello");

// Valores padrão
opt.orElse("Default");                    // Valor fixo
opt.orElseGet(() -> expensiveCalculation()); // Lazy evaluation
opt.orElseThrow(() -> new RuntimeException()); // Exceção customizada

// Transformações
opt.map(String::toUpperCase);             // Transformar se presente
opt.flatMap(this::findRelated);          // Evitar Optional<Optional<T>>
opt.filter(s -> s.length() > 5);         // Filtrar por condição

// Ações
opt.ifPresent(System.out::println);      // Executar se presente
opt.ifPresentOrElse(                     // Java 9+
    System.out::println,
    () -> System.out.println("Empty")
);

public interface Vehicle {
    // Método abstrato tradicional
    void start();
    void stop();

    // Método padrão - pode ser sobrescrito
    default void honk() {
        System.out.println("Beep beep!");
    }

    // Método padrão mais complexo
    default String getInfo() {
        return String.format("Vehicle: %s", this.getClass().getSimpleName());
    }

    // Pode chamar outros métodos
    default void startAndHonk() {
        start();
        honk();
    }
}

public class Car implements Vehicle {
    @Override
    public void start() {
        System.out.println("Car engine starting...");
    }

    @Override
    public void stop() {
        System.out.println("Car engine stopping...");
    }

    // honk() é herdado automaticamente
    // Pode sobrescrever se necessário
    @Override
    public String getInfo() {
        return "Fast car";
    }
}

// Múltiplas interfaces com default methods
public interface Flyable {
    default void fly() {
        System.out.println("Flying...");
    }
}

public class FlyingCar implements Vehicle, Flyable {
    // Se há conflito de nomes, deve resolver explicitamente
    @Override
    public void honk() {
        Vehicle.super.honk(); // Chama implementação específica
        System.out.println("Flying car honk!");
    }
}

public interface MathUtils {
    // Métodos estáticos utilitários
    static double pi() {
        return 3.14159265359;
    }

    static double circleArea(double radius) {
        return pi() * radius * radius;
    }

    // Factory method
    static MathUtils advanced() {
        return new AdvancedMathUtils();
    }
}

// Uso direto
double area = MathUtils.circleArea(5.0);

// Classes principais
LocalDate date = LocalDate.now();              // 2024-01-15
LocalTime time = LocalTime.now();              // 14:30:00
LocalDateTime datetime = LocalDateTime.now();  // 2024-01-15T14:30:00
ZonedDateTime zoned = ZonedDateTime.now();     // 2024-01-15T14:30:00-03:00[America/Sao_Paulo]

// Criação de datas específicas
LocalDate birthday = LocalDate.of(1990, Month.DECEMBER, 25);
LocalTime meetingTime = LocalTime.of(14, 30, 0);
LocalDateTime meeting = LocalDateTime.of(2024, 1, 15, 14, 30);

// Operações matemáticas - sempre retorna nova instância (imutável)
LocalDate tomorrow = date.plusDays(1);
LocalDate nextWeek = date.plusWeeks(1);
LocalDate nextMonth = date.plusMonths(1);
LocalDate lastYear = date.minusYears(1);

// Formatação e parsing
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd/MM/yyyy");
String formatted = date.format(formatter);           // "15/01/2024"
LocalDate parsed = LocalDate.parse("25/12/2024", formatter);

// Formatação localizada
DateTimeFormatter brFormat = DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL)
    .withLocale(new Locale("pt", "BR"));
String brFormatted = date.format(brFormat); // "segunda-feira, 15 de janeiro de 2024"

// ZonedDateTime para timestamps precisos
ZoneId saoPaulo = ZoneId.of("America/Sao_Paulo");
ZoneId tokyo = ZoneId.of("Asia/Tokyo");

ZonedDateTime now = ZonedDateTime.now(saoPaulo);
ZonedDateTime tokyoTime = now.withZoneSameInstant(tokyo);

// Período e duração
LocalDate start = LocalDate.of(2024, 1, 1);
LocalDate end = LocalDate.of(2024, 12, 31);
Period period = Period.between(start, end);
System.out.println(period.getMonths() + " meses"); // 11 meses

LocalTime startTime = LocalTime.of(9, 0);
LocalTime endTime = LocalTime.of(17, 30);
Duration duration = Duration.between(startTime, endTime);
System.out.println(duration.toHours() + " horas"); // 8 horas

// Year, YearMonth para casos específicos
Year currentYear = Year.now();
boolean isLeap = currentYear.isLeap();

YearMonth month = YearMonth.of(2024, 2);
int daysInMonth = month.lengthOfMonth(); // 29 (ano bissexto)

// MonthDay para datas recorrentes (aniversários)
MonthDay christmas = MonthDay.of(Month.DECEMBER, 25);
boolean isChristmasToday = christmas.equals(MonthDay.from(LocalDate.now()));

// Instant para timestamps UTC
Instant timestamp = Instant.now();
long epochMilli = timestamp.toEpochMilli();

ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("JavaScript");

// Executar JavaScript
Object result = engine.eval("Math.sqrt(64)");
System.out.println(result); // 8.0

// Passar objetos Java para JavaScript
engine.put("javaObject", new MyClass());
engine.eval("javaObject.method()");

// Annotations podem ser usadas em qualquer lugar
List<@NonNull String> names;
Map<@NonEmpty String, @Positive Integer> ages;

@Repeatable(Authors.class)
@interface Author {
    String name();
}

@Author(name = "John")
@Author(name = "Jane")
public class Book {
    // ...
}

// Codificar
String encoded = Base64.getEncoder().encodeToString("Hello".getBytes());

// Decodificar
byte[] decoded = Base64.getDecoder().decode(encoded);