Analise o seguinte trecho de código Java:import java.util.Ha...
Analise o seguinte trecho de código Java:
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
public class Iteracao {
public static void main(String[] args) {
Map <Integer, String> produto = new HashMap<Integer, String>();
produto.put(1, "Camisa");
produto.put(2, "Calça");
I. for (Map.Entry< p:produto.entrySet()) { System.out.println(p.getValue()); }
II. Iterator<Map.Entry<Integer, String>> produtos = produto.entrySet().iterator(); while (produtos.hasNext()) { Map.Entry<Integer, String> p = produtos.next(); System.out.println(p.getValue()); }
III. produto.forEach((value) -> { System.out.println(value); });
Gabarito comentado
Confira o gabarito comentado por um dos nossos professores
A alternativa correta é a C - Apenas I e II estão corretas.
Vamos analisar o contexto da questão e por que a alternativa C está correta:
A questão pede para analisar fragmentos de código que iteram sobre um HashMap em Java e imprimem apenas os nomes dos produtos, ou seja, os valores associados às chaves do mapa. Em Java, um HashMap é uma coleção de pares chave-valor onde cada chave é única, e é comum precisar percorrer esses pares para realizar operações com os valores. Há várias formas de se fazer isso, e a questão explora duas dessas formas.
I. O primeiro fragmento de código usa um for avançado (também conhecido como enhanced for loop) para percorrer o conjunto de entradas do mapa (key-value pairs). O método entrySet() é chamado para obter esse conjunto, e para cada entrada, o método getValue() é chamado para imprimir o valor associado, que neste caso é o nome do produto. Este trecho está correto e fará a impressão conforme solicitado.
II. O segundo fragmento de código usa um Iterator para percorrer as entradas do HashMap. O método entrySet().iterator() retorna um iterador sobre o conjunto de entradas. Em seguida, um laço while é utilizado para verificar se ainda há elementos a serem iterados (com hasNext()) e para obter o próximo elemento (com next()). Para cada elemento obtido, o valor é impresso com getValue(). Este trecho também está correto e cumprirá com o que foi pedido.
III. O terceiro fragmento de código tenta usar a expressão lambda introduzida em Java 8 com o método forEach. No entanto, o uso está incorreto por dois motivos. Primeiro, o lambda está estruturado de forma a receber apenas um parâmetro, mas no contexto de um HashMap, o método forEach espera uma BiConsumer, que é uma expressão lambda com dois parâmetros (representando a chave e o valor). Segundo, a expressão lambda fornecida não está corretamente sintetizada, faltando os parâmetros corretos e a seta lambda (->). Logo, esse trecho não compila e está incorreto.
Portanto, apenas os trechos I e II estão corretos e efetuam a impressão dos valores do HashMap como requerido, fazendo com que a alternativa C seja a correta.
Clique para visualizar este gabarito
Visualize o gabarito desta questão clicando no botão abaixo
Comentários
Veja os comentários dos nossos alunos
## Análise do Código Java: Iteração
Este código demonstra a criação e uso inicial de um HashMap para armazenar pares chave-valor. Vamos analisar passo a passo:
**1. Importação de Bibliotecas:**
* `import java.util.HashMap;`: Importa a classe `HashMap` do pacote `java.util`. Essa classe implementa a interface `Map` e é usada para criar coleções associativas que armazenam pares chave-valor.
* `import java.util.Iterator;`: Importa a interface `Iterator` do pacote `java.util`. Essa interface define um iterador para percorrer coleções. (Neste código específico, ele ainda não é utilizado).
* `import java.util.Map;`: Importa a interface `Map` do pacote `java.util`. Essa interface define operações básicas para coleções associativas (chave-valor).
**2. Classe `Iteracao`:**
* `public class Iteracao {`: Declara uma classe pública chamada `Iteracao`.
**3. Método `main`:**
* `public static void main(String[] args) {`: Este é o método `main`, o ponto de entrada da aplicação. É onde a execução do programa começa.
**4. Criando um HashMap:**
* `Map<Integer, String> produto = new HashMap<Integer, String>();`:
* Declara um mapa chamado `produto`.
* Especifica o tipo genérico do mapa:
* Chave (`Integer`): Define que as chaves do mapa serão do tipo inteiro.
* Valor (`String`): Define que os valores do mapa serão do tipo string.
* Cria uma nova instância do `HashMap` usando o construtor padrão.
**5. Adicionando Elementos ao HashMap:**
* `produto.put(1, "Camisa");`:
* Adiciona um novo par chave-valor ao mapa `produto`.
* Chave: `1` (um inteiro).
* Valor: `"Camisa"` (uma string).
* `produto.put(2, "Calça");`:
* Adiciona outro par chave-valor ao mapa `produto`.
* Chave: `2` (um inteiro).
* Valor: `"Calça"` (uma string).
**Observação:**
* O código atual cria um HashMap com dois pares iniciais. Para iterar e exibir o conteúdo do mapa, seria necessário utilizar um loop ou a interface `Iterator`.
**Exemplo de iteração com loop:**
```java
for (Map.Entry<Integer, String> entry : produto.entrySet()) {
System.out.println("Chave: " + entry.getKey() + ", Valor: " + entry.getValue());
}
```
Este código itera sobre o conjunto de entradas (`entrySet`) do mapa e imprime cada chave e seu valor correspondente.
Fonte: Gemini
Clique para visualizar este comentário
Visualize os comentários desta questão clicando no botão abaixo
Conheça nossos planos