DEV Community: FUNDAMENTOS JAVA

12.5 Reflection: parameter names

FUNDAMENTOS JAVA — Sat, 03 May 2025 03:02:57 +0000

Nova funcionalidade: Agora é possível recuperar os nomes dos parâmetros de métodos e construtores usando reflection.

Como fazer:

Use o método getConstructor(...) para obter o construtor desejado.
Em seguida, chame getParameters() para obter um array de Parameter.
Use getName() para acessar o nome de cada parâmetro.

Importante!

Por padrão, os nomes exibidos serão genéricos (arg0, arg1).
Para ver os nomes reais, é necessário compilar o código com a flag:

-parameters

Exemplo com flag:

javac -parameters Usuario.java

Sem essa flag:
isNamePresent() retornará false.
Os nomes continuarão como arg0, arg1, etc.

Antes do Java 8:
Era possível recuperar nomes com -g (debug), mas exigia manipulação de bytecode.

Dependia de bibliotecas externas, como o Paranamer:

Paranamer paranamer = new CachingParanamer();
String[] parameterNames = paranamer.lookupParameterNames(constructor);

Vantagens da nova abordagem:

Evita dependências externas.
Facilita o uso de reflection de forma mais limpa e segura.

🛠️ Como compilar com a flag -parameters:
No terminal, use:

javac -parameters Usuario.java ReflectionTeste.java

E depois execute:

java ReflectionTeste

🧾 Saída esperada (com -parameters):

true: nome
true: pontos

🔁 Saída sem a flag -parameters:

false: arg0
false: arg1

💡 Importante: Para que os nomes reais dos parâmetros apareçam (nome, pontos), compile com a flag -parameters.

Rodar REBUILD PROJECT

ReflectionComParametro.java

12.4 Fim da Permgen

FUNDAMENTOS JAVA — Sat, 03 May 2025 02:24:18 +0000

O que mudou: A PermGen, uma área da memória da JVM usada para armazenar metadados de classes, foi removida a partir do Java 8.

Impacto: Não ocorrerá mais o erro clássico:
java.lang.OutOfMemoryError: PermGen.

Substituição: Agora é usada a Metaspace, uma área de memória nativa (fora do heap da JVM) para armazenar os metadados das classes.

Inspiração: Solução similar já era usada em JVMs como o JRockit da Oracle e na JVM da IBM.

Referência oficial (JEP 122):
Removendo a PermGen - JEP 122

Mais detalhes sobre performance e migração:
Java 8 – PermGen vs Metaspace (artigo na DZone)

Antes:
-XX:PermSize e -XX:MaxPermSize.

⚠️ Novos parâmetros:
-XX:MetaspaceSize (tamanho inicial).
-XX:MaxMetaspaceSize (limite máximo, se definido).

Onde alterar:

Memory Indicator

Anotações Repetidas (Repeating Annotations)

FUNDAMENTOS JAVA — Tue, 29 Apr 2025 22:00:01 +0000

1 Problema antes do Java 8
Não era possível declarar a mesma anotação várias vezes.

Tentativa gerava erro: Duplicate annotation.

2 Solução: @Repeatable
Agora é possível usar anotações múltiplas em um mesmo elemento.

Definindo a anotação repetível:
Usar @Repeatable apontando para um "container" (ex.: @Roles):

@Repeatable(Roles.class) @Documented @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.ANNOTATION_TYPE, ElementType.TYPE}) public @interface Role { String value(); }

Container de anotações:
@Documented @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.ANNOTATION_TYPE, ElementType.TYPE}) public @interface Roles { Role[] value(); }

Aplicação prática:
@Role("presidente") @Role("diretor") public class RelatorioController { }

3 Recuperando anotações com Reflection
Método getAnnotationsByType facilita acesso:

RelatorioController controller = new RelatorioController(); Role[] annotationsByType = controller.getClass().getAnnotationsByType(Role.class); Arrays.asList(annotationsByType) .forEach(a -> System.out.println(a.value()));

Exemplo: ExemploAnotacoesRepetidas.java

Limitações da inferência no lambda

FUNDAMENTOS JAVA — Tue, 29 Apr 2025 21:59:51 +0000

1 Problemas de inferência com lambdas encadeados
Method reference funciona sem problemas:

usuarios.sort(Comparator.comparingInt(Usuario::getPontos) .thenComparing(Usuario::getNome));

Lambda equivalente pode não compilar:

usuarios.sort(Comparator.comparingInt(u -> u.getPontos()) .thenComparing(u -> u.getNome())); // Não compila

2 Soluções para compilar lambdas encadeados

Explicitando o tipo no lambda:

usuarios.sort(Comparator.comparingInt((Usuario u) -> u.getPontos()) .thenComparing(u -> u.getNome()));

Quebrando o encadeamento:

Comparator<Usuario> comparator = Comparator.comparing(u -> u.getPontos()); usuarios.sort(comparator.thenComparing(u -> u.getNome()));

Forçando tipo genérico do método:

usuarios.sort(Comparator.<Usuario>comparingInt(u -> u.getPontos()) .thenComparing(u -> u.getNome()));

3 Preferência por method reference
Method reference (Usuario::getPontos) facilita a inferência dos tipos.

Usado principalmente em interfaces fluentes como Comparator.reversed().

Exemplo: método reversed()

usuarios.sort(Comparator.comparingInt(Usuario::getPontos).reversed());

Lambda precisa de tipo explícito:

usuarios.sort(Comparator.comparingInt((Usuario u) -> u.getPontos()).reversed());

Exemplo: ExemploInferenciaEncadeamento.java

Qual é o tipo de uma expressão Lambda?

FUNDAMENTOS JAVA — Tue, 29 Apr 2025 21:59:36 +0000

1 Lambda precisa ter um tipo funcional
Lambdas não podem ser atribuídas a tipos que não são interfaces funcionais, como Object.

Exemplo que não compila:

Object o = () -> { System.out.println("eu sou um runnable!"); }; new Thread(o).start(); // Erro

2 Lambda atribuída corretamente a uma interface funcional
Atribuindo explicitamente para Runnable:

Runnable r = () -> { System.out.println("eu sou um runnable!"); }; new Thread(r).start(); // Correto

3 Lambda passada diretamente como argumento
Quando passamos diretamente no construtor, o compilador usa o contexto para inferir o tipo:

new Thread(() -> { System.out.println("eu sou um runnable?"); }).start();

O construtor Thread(Runnable r) espera um Runnable, então o compilador infere que a lambda é Runnable.

4 Target Type

O tipo esperado pelo compilador baseado no contexto é chamado de Target Type.

O Target Type permite:

Inferir o tipo da expressão lambda;
Reconhecer que uma mesma lambda pode representar diferentes interfaces funcionais.

Exemplo com mesma expressão lambda e diferentes tipos:

Callable<String> c = () -> "retorna uma String"; PrivilegedAction<String> p = () -> "retorna uma String";

Na primeira linha: Callable.
Na segunda linha: PrivilegedAction.
O Target Type define o significado.

5 O mesmo acontece com Method Reference

A method reference também usa Target Type para inferência.

Exemplo com method reference
Callable<String> c = callable::call; PrivilegedAction<String> action = callable::call;

A mesma referência callable::call pode se adaptar a diferentes interfaces.

6 Diferença entre Lambda e Method Reference
Method references tornam a inferência mais forte, porque o tipo está mais explícito.

Além disso, é permitida a conversão entre interfaces funcionais compatíveis.

Exemplo: ExemploTargetType.java

Conversões entre interfaces funcionais

FUNDAMENTOS JAVA — Tue, 29 Apr 2025 21:59:30 +0000

1 Não existe conversão automática entre interfaces funcionais equivalentes
Mesmo que duas interfaces sejam "equivalentes" (ex.: Supplier e PrivilegedAction), o compilador não faz a conversão automaticamente.

2 Exemplo de método que recebe um Supplier
private void execute(Supplier<String> supplier) { System.out.println(supplier.get()); }

Uso correto com Supplier:

Supplier<String> supplier = () -> "executando um supplier"; execute(supplier);

3 Tentativa incorreta usando PrivilegedAction
Erro: o compilador não permite passar PrivilegedAction diretamente.

PrivilegedAction<String> action = () -> "executando uma ação"; execute(action); // Não compila

Motivo: O método execute(Supplier) não aceita diretamente um PrivilegedAction.

4 Como converter usando Method Reference
Usamos uma referência de método (action::run) para indicar a adaptação explicitamente.

PrivilegedAction<String> action = () -> "executando uma ação"; execute(action::run);

Exemplo: ExemploInferenciaTipos.java

Situações de Ambiguidade com Expressões Lambda

FUNDAMENTOS JAVA — Sat, 26 Apr 2025 18:01:55 +0000

Tópicos Principais:
Inferência de Tipos em Lambdas:

Java 8 pode inferir o tipo de uma expressão lambda baseado no contexto
Funciona bem quando há apenas uma interface funcional compatível

Casos de Ambiguidade:

Ocorrem quando múltiplas interfaces funcionais têm a mesma assinatura

Exemplo entre Supplier e PrivilegedAction:

Ambos têm um único método abstrato sem parâmetros que retorna T

Problema com Sobrecarga de Métodos:

Quando existem métodos sobrecarregados com diferentes interfaces funcionais compatíveis
O compilador não consegue determinar qual método usar

Solução para Ambiguidade:

Uso de casting explícito para especificar o tipo da lambda
Alternativa: usar referência de método quando possível

Ver: AmbiguidadeLambda.java

Cap 12 Apêndice: mais Java 8 com reflection, JVM, APIs e limitações

FUNDAMENTOS JAVA — Sat, 26 Apr 2025 17:46:50 +0000

12.1: Novos Detalhes na Linguagem (Operador Diamante Melhorado)

Tópicos Principais:
Operador Diamante (<>):

Introduzido no Java 7 para reduzir código redundante
Permite substituir new ArrayList() por new ArrayList<>()
Limitação original: só funcionava na declaração de variáveis

Melhorias no Java 8:
Inferência de tipos ampliada para contextos adicionais
Agora funciona em:

Chamadas de métodos
Retornos de métodos
Argumentos de métodos

Casos de Uso:

repositorio.adiciona(new ArrayList<>()) - agora funciona
repositorio.adiciona(Collections.emptyList()) - também funciona
Não precisa mais de anotações explícitas de tipo

Comparação Java 7 vs Java 8:
Java 7 exigia:

repositorio.adiciona(new ArrayList<Usuario>());
repositorio.adiciona(Collections.<Usuario>emptyList());

Java 8 aceita:

repositorio.adiciona(new ArrayList<>());
repositorio.adiciona(Collections.emptyList());

JEP Relacionado:
JEP 101: Generalized Target-Type Inference
Link: http://openjdk.java.net/jeps/101

Ver OperadorDiamanteExemplo.java

11.9 Sistema de assinaturas

FUNDAMENTOS JAVA — Sat, 19 Apr 2025 04:42:26 +0000

📘 Resumo do Sistema de Assinaturas (Capítulo 11.9)
Esse tópico mostra como modelar um sistema de assinaturas mensais usando Java 8, representando o tempo de vigência da assinatura e o cálculo do valor total pago.

Modelagem da classe Subscription:

Utiliza Optional para a data de término, tornando explícito o tratamento de assinaturas ativas/encerradas
Dois construtores: um para assinaturas ativas (sem data de término) e outro para assinaturas encerradas
Método getTotalPaid() que calcula automaticamente o valor total pago

Cálculo de duração:

Uso de ChronoUnit.MONTHS.between() para calcular meses entre datas
Utilização inteligente de Optional.orElse() para tratar assinaturas ativas (usando data atual)

Operações com streams:

Cálculo do total pago por todas as assinaturas com map e reduce
Filtragem de assinaturas ativas com filter(sub -> sub.getEnd().isEmpty())
Cálculo de estatísticas como valor médio por assinatura

Vantagens do design:

Código limpo sem verificações de null
Lógica de negócio encapsulada na classe Subscription
Flexibilidade para diferentes tipos de consultas e relatórios

Exemplos práticos:

Cálculo individual por assinatura
Agregação de valores totais
Filtros e estatísticas sobre a coleção de assinaturas

Esta implementação demonstra como usar recursos modernos do Java (Optional, Streams, Date/Time API) para modelar um sistema de assinaturas de forma elegante e eficiente.

Ver exemplo: SubscriptionSystem.java

11.8 Relatórios com datas

FUNDAMENTOS JAVA — Sat, 19 Apr 2025 04:23:43 +0000

Agrupamento por data:

Usamos YearMonth.from(p.getDate()) para agrupar pagamentos por mês/ano, ignorando dias e horários específicos
Collectors.groupingBy() é o coletor principal para essa operação

Cálculo do valor total por período:

Combinamos groupingBy() com reducing() para somar os valores dos pagamentos
Utilizamos o método getTotalAmount() da classe Payment para obter o valor total de cada pagamento

Contagem de pagamentos por período:

Usamos Collectors.counting() para contar quantos pagamentos ocorreram em cada mês

Ordenação dos resultados:

Os resultados são exibidos em ordem cronológica usando sorted(Comparator.comparing(Map.Entry::getKey))

Visualização dos dados:
Mostramos três relatórios diferentes:

Lista detalhada de pagamentos por mês
Valor total faturado por mês
Quantidade de pagamentos por mês

Esta implementação demonstra como gerar relatórios temporais eficientes usando as APIs de data do Java 8 e streams.

Ver DateReportExample.java

11.7 Qual é nosso cliente mais especial?

FUNDAMENTOS JAVA — Sat, 19 Apr 2025 04:13:50 +0000

O "mais especial" pode ser definido por diferentes critérios (ex.: quem gastou mais, quem fez mais compras, etc.).

Praticar a flexibilidade do Stream API: O código mostrado no livro foca em calcular o total gasto por cliente (Map), assumindo que o "mais especial" é quem contribuiu mais financeiramente (maior valor acumulado).

Agrupa os pagamentos por cliente (groupingBy).
Soma os valores de todos os pagamentos de cada cliente (reducing).

Map<Customer, BigDecimal> totalValuePerCustomer = payments.stream()
    .collect(Collectors.groupingBy(
        Payment::getCustomer,
        Collectors.reducing(BigDecimal.ZERO, paymentToTotal, BigDecimal::add)
    ));

Ao ordenar o resultado:

totalValuePerCustomer.entrySet().stream()
    .sorted(Comparator.comparing(Map.Entry::getValue))
    .forEach(System.out::println);

O "cliente mais especial" seria o último da lista (maior valor), no caso do livro:
Adriano Almeida=450

Outros Critérios Possíveis
Se "mais especial" tivesse outro significado, o código mudaria. Por exemplo:

Cliente com mais compras:

Map<Customer, Long> countPurchases = payments.stream()
    .collect(Collectors.groupingBy(
        Payment::getCustomer,
        Collectors.counting()
    ));

Cliente com o produto mais caro:

Map<Customer, Optional<Product>> mostExpensiveProduct = payments.stream()
    .collect(Collectors.groupingBy(
        Payment::getCustomer,
        Collectors.flatMapping(
            p -> p.getProducts().stream(),
            Collectors.maxBy(Comparator.comparing(Product::getPrice))
        )
    ));

Por Que o Livro Escolheu Esse Exemplo?
Didático: Mostra como combinar groupingBy com reducing para resolver problemas complexos.

Desafio: A versão inicial do código é intencionalmente densa para depois refatorar (com paymentToTotal ou getTotalAmount).

Preparação: Ensina a pensar em operações aninhadas (redução dentro de redução), úteis para processamento de dados.

Ver:
SpecialCustomerExample.java

11.6 Quais são os produtos de cada cliente?

FUNDAMENTOS JAVA — Tue, 15 Apr 2025 01:14:15 +0000

Objetivo: Obter um Map> associando cada cliente à lista total de produtos comprados.

Abordagem inicial: Agrupando por cliente

Map<Customer, List<Payment>> customerToPayments = payments.stream() .collect(Collectors.groupingBy(Payment::getCustomer));

Porém, queremos produtos, não pagamentos.

Tentativa 1: Mapeando diretamente os produtos

Resultado intermediário com listas aninhadas:

Map<Customer, List<List<Product>>> customerToProductsList = payments.stream() .collect(Collectors.groupingBy( Payment::getCustomer, Collectors.mapping(Payment::getProducts, Collectors.toList()) ));

Saída contém List>, o que não é o desejado.

Solução com duas etapas: Flatten com flatMap

Achatar as listas aninhadas usando flatMap:

Map<Customer, List<Product>> customerToProducts2steps = customerToProductsList.entrySet().stream() .collect(Collectors.toMap( Map.Entry::getKey, e -> e.getValue().stream() .flatMap(List::stream) .collect(Collectors.toList()) ));

Solução em uma única etapa (menos legível)

Mesma ideia, mas com tudo encadeado:

Map<Customer, List<Product>> customerToProducts1step = payments.stream() .collect(Collectors.groupingBy(Payment::getCustomer, Collectors.mapping(Payment::getProducts, Collectors.toList()))) .entrySet().stream() .collect(Collectors.toMap( Map.Entry::getKey, e -> e.getValue().stream() .flatMap(List::stream) .collect(Collectors.toList()) ));

Desvantagem: Código difícil de entender.

Solução alternativa com Collectors.reducing

Usando reducing para acumular listas de produtos:

Map<Customer, List<Product>> customerToProducts = payments.stream() .collect(Collectors.groupingBy(Payment::getCustomer, Collectors.reducing( Collections.emptyList(), Payment::getProducts, (l1, l2) -> { List<Product> l = new ArrayList<>(); l.addAll(l1); l.addAll(l2); return l; } ) ));

Observação: Não existe um método auxiliar no Java para unir listas diretamente, o que exige escrever o BinaryOperator manualmente.

Exemplo: ProdutosPorClienteExemplo.java