Resumo - Operações do HashMap

Parte da seção Lógica e Fluxo do Journey de Java da Coddy. Lição 21 de 59.

Desafio

Fácil

Crie um método chamado processHashMap que receba um argumento:

Um HashMap chamado products, em que:
- As chaves representam nomes de produtos (String).
- Os valores representam preços (Double).

Operações a serem realizadas

Encontre o produto com o preço mais alto.
- Se vários produtos tiverem o mesmo preço mais alto, retorne qualquer um deles.
- Se o HashMap estiver vazio, retorne uma string vazia ("").
Filtre os produtos que tenham um preço maior que 50.00 e armazene-os em um novo HashMap.
Calcule o preço médio de todos os produtos.
- Se o HashMap estiver vazio, a média deverá ser 0.0.

Formato do retorno

O método deve retornar um novo HashMap com os seguintes pares de chave e valor:

Chave	Valor
`"Highest"`	O nome do produto com o preço mais alto (`String`).
`"Filtered"`	Um HashMap (`HashMap<String, Double>`) contendo apenas produtos com preços maiores que `50.00`.
`"Average"`	O preço médio de todos os produtos (`Double`).

Experimente você mesmo

import java.util.LinkedHashMap;
import java.util.HashMap;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.Scanner;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import java.lang.reflect.Type;

public class Main {
    public static HashMap<String, Object> processHashMap(HashMap<String, Double> products) {
        // Escreva seu código aqui
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String productsString = scanner.nextLine();

        // Converta a string JSON para HashMap
        Type mapType = new TypeToken<HashMap<String, Double>>(){}.getType();
        HashMap<String, Double> products = new Gson().fromJson(productsString, mapType);

        HashMap<String, Object> result = processHashMap(products);

        // Ordene o mapa Filtered para garantir uma saída consistente
        Map<String, Double> filteredMap = (Map<String, Double>) result.get("Filtered");
        if (filteredMap != null && !filteredMap.isEmpty()) {
            Map<String, Double> sortedFiltered = filteredMap.entrySet().stream()
                .sorted(Map.Entry.comparingByKey())
                .collect(Collectors.toMap(
                    Map.Entry::getKey,
                    Map.Entry::getValue,
                    (a, b) -> b,
                    LinkedHashMap::new
                ));
            result.put("Filtered", sortedFiltered);
        }
        
        System.out.println(result);
    }
}