Java 9 — A Era dos Módulos

// module-info.java - Definição de módulo
module com.example.userservice {
    // Dependências explícitas
    requires java.base;          // Implícito em todos os módulos
    requires java.sql;           // Para JDBC
    requires transitive java.logging;  // Transitiva - quem usar este módulo terá logging

    // O que este módulo exporta (API pública)
    exports com.example.userservice.api;
    exports com.example.userservice.model to
        com.example.ui,          // Apenas para módulos específicos
        com.example.reporting;

    // Serviços que este módulo oferece
    provides com.example.userservice.spi.UserProvider
        with com.example.userservice.impl.DatabaseUserProvider;

    // Serviços que este módulo consome
    uses com.example.config.ConfigProvider;

    // Reflection para frameworks (Spring, Hibernate)
    opens com.example.userservice.entity to
        org.hibernate.orm.core,
        com.fasterxml.jackson.databind;
}

myapp/
├── src/
│   ├── com.example.core/
│   │   ├── module-info.java
│   │   └── com/example/core/
│   │       ├── User.java
│   │       └── UserService.java
│   ├── com.example.ui/
│   │   ├── module-info.java
│   │   └── com/example/ui/
│   │       └── UserController.java
│   └── com.example.app/
│       ├── module-info.java
│       └── com/example/app/
│           └── Main.java

// Java 9 - Conciso e claro
List<String> languages = List.of("Java", "Python", "JavaScript");
Set<Integer> numbers = Set.of(1, 2, 3, 4, 5);
Map<String, Integer> ages = Map.of(
    "Alice", 30,
    "Bob", 25,
    "Charlie", 35
);

// Antes do Java 9 - Verboso
List<String> oldWay = Arrays.asList("Java", "Python", "JavaScript");
List<String> immutable = Collections.unmodifiableList(oldWay);

Set<Integer> oldNumbers = new HashSet<>();
oldNumbers.add(1);
oldNumbers.add(2);
// ... mais código repetitivo

// Map ainda pior antes do Java 9
Map<String, Integer> oldAges = new HashMap<>();
oldAges.put("Alice", 30);
oldAges.put("Bob", 25);
// ...

// Características das factory collections
// 1. Imutáveis - UnsupportedOperationException se tentar modificar
// 2. Não permitem elementos null
// 3. Para Set e Map, detectam duplicatas em compile-time quando possível

try {
    languages.add("C++"); // UnsupportedOperationException
} catch (UnsupportedOperationException e) {
    System.out.println("Collection is immutable!");
}

// List.of() vs Arrays.asList()
List<String> arraysList = Arrays.asList("a", "b");  // Mutável (mas tamanho fixo)
arraysList.set(0, "c");  // OK

List<String> listOf = List.of("a", "b");  // Completamente imutável
// listOf.set(0, "c");  // UnsupportedOperationException

// Overloads otimizados para até 10 elementos
List.of();                           // Lista vazia
List.of("a");                        // 1 elemento
List.of("a", "b");                   // 2 elementos
// ... até List.of(e1, e2, ..., e10)
List.of("a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k"); // Varargs

// Map com até 10 pares chave-valor
Map.of("k1", "v1", "k2", "v2");     // 2 pares
Map.ofEntries(                       // Para mais que 10 pares
    entry("key1", "value1"),
    entry("key2", "value2"),
    entry("key3", "value3")
);

// takeWhile - pega elementos enquanto condição for verdadeira
List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8);

List<Integer> lessThanFive = numbers.stream()
    .takeWhile(n -> n < 5)
    .collect(Collectors.toList());
// Resultado: [1, 2, 3, 4]

// dropWhile - descarta elementos enquanto condição for verdadeira
List<Integer> fiveOrGreater = numbers.stream()
    .dropWhile(n -> n < 5)
    .collect(Collectors.toList());
// Resultado: [5, 6, 7, 8]

// Exemplo prático: processando log ordenado por timestamp
List<LogEntry> logs = getLogEntries(); // ordenados por timestamp

// Pegar apenas logs de hoje
LocalDate today = LocalDate.now();
List<LogEntry> todayLogs = logs.stream()
    .dropWhile(log -> log.getDate().isBefore(today))
    .takeWhile(log -> log.getDate().equals(today))
    .collect(Collectors.toList());

// Stream.ofNullable - cria stream de valor que pode ser null
String possiblyNull = getValue(); // pode retornar null

// Java 9 - elegante
Stream.ofNullable(possiblyNull)
    .map(String::toUpperCase)
    .forEach(System.out::println);

// Antes do Java 9 - verboso
if (possiblyNull != null) {
    Stream.of(possiblyNull)
        .map(String::toUpperCase)
        .forEach(System.out::println);
}

// Útil para flat mapping de valores opcionais
List<Optional<String>> optionals = getOptionalValues();
List<String> values = optionals.stream()
    .flatMap(opt -> opt.map(Stream::of).orElse(Stream.empty()))
    .collect(Collectors.toList());

// Com ofNullable - mais limpo
List<String> valuesClean = optionals.stream()
    .map(opt -> opt.orElse(null))
    .flatMap(Stream::ofNullable)
    .collect(Collectors.toList());

// iterate com predicado - para quando condição for falsa
Stream.iterate(1, n -> n < 100, n -> n * 2)
    .forEach(System.out::println);
// Imprime: 1, 2, 4, 8, 16, 32, 64

// Antes do Java 9 - precisava de takeWhile
Stream.iterate(1, n -> n * 2)
    .takeWhile(n -> n < 100)
    .forEach(System.out::println);

Optional<String> name = findUserName(userId);

// ifPresentOrElse - ação se presente, outra se ausente
name.ifPresentOrElse(
    System.out::println,                    // Se presente
    () -> System.out.println("User not found") // Se ausente
);

// or - alternativa para Optional vazio
Optional<String> result = name
    .or(() -> findUserNameInCache(userId))  // Tenta cache
    .or(() -> Optional.of("Guest"));        // Fallback final

// stream - converte Optional em Stream
List<Optional<String>> optionals = List.of(
    Optional.of("Alice"),
    Optional.empty(),
    Optional.of("Bob"),
    Optional.empty(),
    Optional.of("Charlie")
);

// Extrair apenas valores presentes usando stream()
List<String> names = optionals.stream()
    .flatMap(Optional::stream)  // Converte cada Optional em Stream
    .collect(Collectors.toList());
// Resultado: ["Alice", "Bob", "Charlie"]

// Exemplo prático: buscar configuração com fallbacks
public Optional<String> getConfigValue(String key) {
    return Optional.ofNullable(System.getProperty(key))
        .or(() -> Optional.ofNullable(System.getenv(key)))
        .or(() -> loadFromConfigFile(key))
        .or(() -> getDefaultValue(key));
}

// Usar a configuração
getConfigValue("app.timeout")
    .ifPresentOrElse(
        timeout -> setAppTimeout(Integer.parseInt(timeout)),
        () -> setAppTimeout(30) // valor padrão
    );

public interface PaymentProcessor {

    // Métodos default públicos
    default void processCardPayment(double amount, String cardNumber) {
        logPayment("CARD", amount);
        validateAmount(amount);
        // Lógica específica de cartão
        System.out.println("Processing card payment: $" + amount);
        logSuccess("CARD", amount);
    }

    default void processPixPayment(double amount, String pixKey) {
        logPayment("PIX", amount);
        validateAmount(amount);
        // Lógica específica de PIX
        System.out.println("Processing PIX payment: $" + amount);
        logSuccess("PIX", amount);
    }

    default void processBankTransfer(double amount, String account) {
        logPayment("TRANSFER", amount);
        validateAmount(amount);
        // Lógica específica de transferência
        System.out.println("Processing bank transfer: $" + amount);
        logSuccess("TRANSFER", amount);
    }

    // Métodos privados para reutilização - evitam duplicação
    private void logPayment(String type, double amount) {
        System.out.println("Starting " + type + " payment for $" + amount);
        // Log detalhado aqui
    }

    private void logSuccess(String type, double amount) {
        System.out.println("Successfully processed " + type + " payment for $" + amount);
        // Metrics, audit trail, etc.
    }

    private void validateAmount(double amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("Amount must be positive");
        }
        if (amount > 50000) {
            throw new IllegalArgumentException("Amount exceeds daily limit");
        }
    }

    // Método privado static também é permitido
    private static String formatCurrency(double amount) {
        return String.format("$%.2f", amount);
    }
}

// Interface para cálculos matemáticos
public interface MathUtils {

    default double calculateCircleArea(double radius) {
        validatePositive(radius, "radius");
        return Math.PI * square(radius);
    }

    default double calculateSphereVolume(double radius) {
        validatePositive(radius, "radius");
        return (4.0/3.0) * Math.PI * cube(radius);
    }

    default double calculateRectangleArea(double width, double height) {
        validatePositive(width, "width");
        validatePositive(height, "height");
        return width * height;
    }

    // Métodos privados para reutilização
    private double square(double value) {
        return value * value;
    }

    private double cube(double value) {
        return value * value * value;
    }

    private void validatePositive(double value, String paramName) {
        if (value <= 0) {
            throw new IllegalArgumentException(paramName + " must be positive");
        }
    }
}

// Java 9 - Pode usar variáveis already declared
void processFile(String filename) throws IOException {
    FileInputStream fis = new FileInputStream(filename);
    BufferedReader reader = new BufferedReader(new InputStreamReader(fis));

    // Java 9 - pode usar directly
    try (fis; reader) {
        // Process file
        String line;
        while ((line = reader.readLine()) != null) {
            processLine(line);
        }
    }
    // Resources closed automatically
}

// Antes do Java 9 - precisava redeclarar
void processFileOldWay(String filename) throws IOException {
    FileInputStream fis = new FileInputStream(filename);
    BufferedReader reader = new BufferedReader(new InputStreamReader(fis));

    try (FileInputStream fis2 = fis; BufferedReader reader2 = reader) {
        // Redundant redeclaration
        String line;
        while ((line = reader2.readLine()) != null) {
            processLine(line);
        }
    }
}

// Exemplo mais complexo
public void copyFiles(Path source, Path target) throws IOException {
    InputStream input = Files.newInputStream(source);
    OutputStream output = Files.newOutputStream(target);

    try (input; output) {
        input.transferTo(output);
    }
    // Both streams closed automatically
}

public class CollectionUtils {

    @SafeVarargs
    private static <T> List<T> createSafeList(T... elements) {
        return Arrays.asList(elements);
    }

    public static <T> List<T> of(T... elements) {
        return createSafeList(elements);  // No warnings
    }
}

// Java 9 - HTTP Client (incubator module)
HttpClient client = HttpClient.newHttpClient();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.example.com/users"))
    .header("Accept", "application/json")
    .build();

// Síncrono
HttpResponse<String> response = client.send(request,
    HttpResponse.BodyHandlers.ofString());

// Assíncrono
CompletableFuture<String> asyncResponse = client.sendAsync(request,
    HttpResponse.BodyHandlers.ofString())
    .thenApply(HttpResponse::body);

// Informações sobre o processo atual
ProcessHandle current = ProcessHandle.current();
System.out.println("PID: " + current.pid());
System.out.println("Command: " + current.info().command().orElse("Unknown"));

// Listar todos os processos
ProcessHandle.allProcesses()
    .filter(p -> p.info().command().isPresent())
    .forEach(p -> System.out.println(
        "PID: " + p.pid() + ", Command: " + p.info().command().get()
    ));

// Criar e monitorar processo
Process process = new ProcessBuilder("sleep", "10").start();
process.onExit()
    .thenRun(() -> System.out.println("Process finished"));

// Transparente para o desenvolvedor
String latin = "Hello World";    // 1 byte per char internally
String unicode = "こんにちは";      // 2 bytes per char internally