Java 10 — Inferência de Tipos e Performance

// Antes do Java 10 - Verboso com tipos longos
List<String> nomes = new ArrayList<String>();
Map<String, List<Person>> pessoasPorCidade = new HashMap<String, List<Person>>();
Iterator<Entry<String, Integer>> iterator = map.entrySet().iterator();

// Java 10 - Mais limpo com var
var nomes = new ArrayList<String>();           // List<String> inferido
var pessoasPorCidade = new HashMap<String, List<Person>>(); // Map<String, List<Person>>
var iterator = map.entrySet().iterator();      // Iterator<Entry<String, Integer>>

// Casos simples
var nome = "João Silva";        // String
var idade = 30;                 // int
var salario = 5500.50;         // double
var ativo = true;              // boolean

// Com Streams - elimina types complexos
var nomesComJ = List.of("Ana", "João", "Maria", "José")
    .stream()
    .filter(s -> s.startsWith("J"))
    .map(String::toUpperCase)
    .collect(Collectors.toList());  // List<String> inferido

// Diamond operator fica mais limpo
var pessoas = new ArrayList<Person>();
var cache = new ConcurrentHashMap<String, Object>();

// Com try-with-resources
try (var scanner = new Scanner(System.in);
     var writer = Files.newBufferedWriter(path)) {
    // código aqui
}

public class VarExamples {
    // ❌ NÃO funciona em:

    // 1. Campos de classe
    // var campoDeClasse = "erro";  // ERRO

    // 2. Parâmetros de método
    // public void metodo(var param) { }  // ERRO

    // 3. Tipo de retorno
    // public var metodo() { return "erro"; }  // ERRO

    // 4. Sem inicialização
    public void exemplos() {
        // var sem_valor;  // ERRO - precisa de inicialização

        // 5. Inicialização com null
        // var nulo = null;  // ERRO - tipo não pode ser inferido

        // 6. Lambdas precisam de contexto
        // var lambda = () -> "test";  // ERRO
        // var lambda = (String s) -> s.toUpperCase();  // ERRO

        // ✅ Mas funciona com:
        Function<String, String> func = s -> s.toUpperCase();
        var lambda = func;  // OK - tipo Function<String, String> inferido

        // 7. Array precisa de tipo explícito no lado direito
        // var array = {1, 2, 3};  // ERRO
        var array = new int[]{1, 2, 3};  // OK

        // 8. Expressões polimórficas precisam de cast
        var number = (Number) 42;  // OK - sem cast seria int
    }
}

// ✅ BOM: Quando o tipo é óbvio do lado direito
var path = Paths.get("arquivo.txt");
var date = LocalDate.now();
var users = userService.findAllUsers();

// ✅ BOM: Com tipos genéricos complexos
var complexMap = new HashMap<String, List<Map<String, Object>>>();

// ❌ EVITAR: Quando o tipo não é claro
var data = getData();        // Que tipo retorna getData()?
var result = process();      // Não fica claro o tipo

// ✅ MELHOR: Seja explícito quando necessário
UserDto userData = getData();
ProcessResult result = process();

// ✅ BOM: Em loops for-each
for (var person : pessoas) {
    System.out.println(person.getName());
}

// ✅ BOM: Com APIs fluentes
var result = Optional.of("test")
    .map(String::toUpperCase)
    .filter(s -> s.length() > 3)
    .orElse("default");

// No IDE ou compilação, você pode verificar que tipo foi inferido
var list = new ArrayList<String>();
// Hover no IDE mostra: ArrayList<String>

var stream = list.stream()
    .filter(s -> s.startsWith("A"))
    .map(String::toUpperCase);
// Tipo inferido: Stream<String>

// Transparente para desenvolvedores - melhoria interna da JVM
// Beneficia operações como:
// - Biased locking revocation
// - Stack sampling
// - Algumas operações de debug/profiling

// Antes: Para todas as threads
// Agora: Para apenas threads específicas quando necessário

Optional<String> nome = findUserName(id);

// Java 8-9: verboso ou confuso
String valor1 = nome.get();  // Confuso - pode dar exceção
String valor2 = nome.orElseThrow(NoSuchElementException::new);  // Verboso

// Java 10: expressivo e conciso
String valor3 = nome.orElseThrow();  // Claro que pode lançar exceção

// Exemplo prático
public User findUserById(Long id) {
    return userRepository.findById(id)
        .orElseThrow();  // NoSuchElementException se não encontrar
}

// Com mensagem customizada (ainda melhor)
public User findUserByIdWithMessage(Long id) {
    return userRepository.findById(id)
        .orElseThrow(() -> new UserNotFoundException("User not found: " + id));
}

// Antes do Java 10
List<String> imutavelAntes = pessoas.stream()
    .map(Person::getName)
    .collect(Collectors.toList());
imutavelAntes = Collections.unmodifiableList(imutavelAntes);  // Wrap necessário

// Java 10 - direto
List<String> imutavel = pessoas.stream()
    .map(Person::getName)
    .collect(Collectors.toUnmodifiableList());

Set<String> emails = pessoas.stream()
    .map(Person::getEmail)
    .collect(Collectors.toUnmodifiableSet());

Map<String, Integer> idades = pessoas.stream()
    .collect(Collectors.toUnmodifiableMap(
        Person::getName,
        Person::getAge
    ));

// Tentativa de modificação resulta em UnsupportedOperationException
// imutavel.add("novo");  // ❌ Erro em runtime

List<String> original = Arrays.asList("a", "b", "c");
List<String> copia = List.copyOf(original);  // Cópia imutável

// Otimização inteligente: se original já for imutável, retorna a mesma instância
List<String> jaImutavel = List.of("x", "y", "z");
List<String> "copia"2 = List.copyOf(jaImutavel);  // Retorna a mesma instância!
System.out.println(jaImutavel == copia2);  // true - mesma referência

// Funciona com qualquer Collection
Set<String> conjuntoOriginal = new HashSet<>(Arrays.asList("1", "2", "3"));
Set<String> conjuntoCopia = Set.copyOf(conjuntoOriginal);  // Imutável

Map<String, Integer> mapaOriginal = new HashMap<>();
mapaOriginal.put("a", 1);
mapaOriginal.put("b", 2);
Map<String, Integer> mapaCopia = Map.copyOf(mapaOriginal);  // Imutável

// Null safety - elementos null causam NullPointerException
List<String> comNull = Arrays.asList("a", null, "c");
// List<String> erro = List.copyOf(comNull);  // ❌ NullPointerException