Resumen - Operaciones de HashMap

Parte de la sección Lógica y Flujo del Journey de Java de Coddy — lección 21 de 59.

Desafío

Fácil

Crea un método llamado processHashMap que toma un argumento:

Un HashMap llamado products donde:
- Claves representan nombres de productos (String).
- Valores representan precios (Double).

Operaciones a Realizar

Encuentra el producto con el precio más alto.
- Si múltiples productos tienen el mismo precio más alto, devuelve cualquiera de ellos.
- Si el HashMap está vacío, devuelve una cadena vacía ("").
Filtra los productos que tienen un precio mayor que 50.00 y almacénalos en un nuevo HashMap.
Calcula el precio promedio de todos los productos.
- Si el HashMap está vacío, el promedio debe ser 0.0.

Formato de Retorno

El método debe devolver un nuevo HashMap con las siguientes pares clave-valor:

Clave	Valor
`"Highest"`	El nombre del producto con el precio más alto (`String`).
`"Filtered"`	Un HashMap (`HashMap<String, Double>`) que contiene solo productos con precios mayores que `50.00`.
`"Average"`	El precio promedio de todos los productos (`Double`).

Pruébalo tú mismo

import java.util.LinkedHashMap;
import java.util.HashMap;
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) {
        // Escribe tu código aquí
    }

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

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

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

        // Ordenar el mapa Filtered para asegurar salida 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);
    }
}