Carlos Fernández García

Ejercicio 1

Crea un programa en Java que gestione un registro de empleados utilizando un TreeMap donde: La clave sea el ID del empleado (un número único asignado automáticamente al agregar un empleado). El valor sea el nombre del empleado. El programa debe: Agregar un empleado: Solicitar el nombre y asignar automáticamente un ID único (puedes usar el tamaño del TreeMap + 1 como base). Listar todos los empleados: Mostrar los empleados ordenados por su ID (esto se hará automáticamente con TreeMap). Buscar un empleado por ID: Solicitar un ID y mostrar el nombre del empleado si existe. Eliminar un empleado: Solicitar un ID y eliminar al empleado correspondiente si existe. Extras opcionales: Mostrar el ID más bajo y más alto en el registro. Mostrar cuántos empleados hay registrados.

package treemap;

import java.util.Scanner;
import java.util.TreeMap;

public class Ejercicio1 {

	public static void main(String[] args) {
		

	}

}

class Empleado{
	int id;
	String nombre;
	
	private int agregarId(Scanner entrada) {
		
		while(true) {
			try {
				System.out.println("Introduce el codigo del empleado");
				this.id=Integer.parseInt(entrada.nextLine());
				
				if(this.id<1) {
					System.out.println("El codigo de empleado tiene que ser mayor que uno, introducelo de nuevo");
				}else {
					return this.id;
				}
			}catch(NumberFormatException e) {
				System.err.println("Formato de codigo no valido, introducelo de nuevo");
			}
		}
	}
	
	private String agregarNombre(Scanner entrada) {
		while(true) {
			System.out.println("Introduce el nombre del empleado:");
			this.nombre=entrada.nextLine();
			
			if(this.nombre.equals("")) {
				System.out.println("El nombre del empleado no puede quedar en blanco, introducelo de nuevo");
			}else {
				return this.nombre;
			}
		}
	}
	
	public TreeMap<Integer,String> eliminarEmpleado(Scanner entrada,TreeMap<Integer,String> listaEmpleados){
		if(listaEmpleados.isEmpty()) {
			System.out.println("Aun no hay empleados dados de alta");
		}else {
			
			this.id=agregarId(entrada);
			
			if(!listaEmpleados.containsKey(this.id)) {
				System.out.println("Ningun empelado con ese id");
			}else {
				char respuesta = ' ';

	            
	            while (true) {
	                System.out.println("¿Seguro que quieres borrar el empleado " + listaEmpleados.get(this.id) + " (s)(n)");
	                respuesta = entrada.nextLine().toLowerCase().charAt(0);
	                
	                if (respuesta != 's' && respuesta != 'n') {
	                    System.out.println("La respuesta tiene que ser (s) o (n)");
	                } else {
	                    break;
	                }
	            }
	            
	            // 
	            if (respuesta == 's') {
	            	listaEmpleados.remove(this.id);
	                System.out.println("Empleado borrado con éxito");
	                System.out.println("Quedan " + listaEmpleados.size() + " empleados dados de lata en la empresa");
	            } else {
	                System.out.println("Operación de borrado de empleados abortada");
	            }
			}
			
			
			
		
		}
		
		return listaEmpleados;
	}
	
	public TreeMap<Integer,String> agregarEmpleado(Scanner entrada,TreeMap<Integer,String> listaEmpleados){
		
		this.id=agregarId(entrada);
		
		if(listaEmpleados.containsKey(this.id)) {
			System.out.println("El codigo de empleado ya esta en uso");
		}else {
			this.nombre=agregarNombre(entrada);
			
			listaEmpleados.put(this.id, this.nombre);
			System.out.println("Empleado agregado corretamente");
		}
		
		return listaEmpleados;
	}
	
	public void buscarEmpleados(Scanner entrada,TreeMap<Integer,String> listaEmpleados) {
		if(listaEmpleados.isEmpty()) {
			System.out.println("Aun no hya empleados dados de alta");
		}else {
			this.id=agregarId(entrada);
			
			if(listaEmpleados.containsKey(this.id)) {
				System.out.println("Empleado encontrado");
				System.out.println("Id:" + this.id +"\nNombre:" + listaEmpleados.get(this.id));
			}else {
				System.out.println("El empleado no se encuentra dado de alta");
			}
		}
	}
	
	public void listarEmpleados(TreeMap<Integer,String> listaEmpleados) {
		if(listaEmpleados.isEmpty()) {
			System.out.println("Aun no hay empleados dados de alta");
		}else {
			System.out.println("Lista de empleados");
			for (Integer codigo : listaEmpleados.keySet()) {
				System.out.println("Id:" + codigo + "\nNombre:" + listaEmpleados.get(codigo));
			}
		}
	}
}

class MenuEjercicio1{
	TreeMap<Integer,String> listaEmpleados=new TreeMap<Integer,String>();
	Empleado empleado=new Empleado();
	Scanner entrada=new Scanner(System.in);
	int menu;
	
	public void mostrarMenu() {
		
		do {
			System.out.println("Menu empleado");
			System.out.println("1. Añadir empleado");
			System.out.println("2. Lista empleados");
			System.out.println("3. Buscar empleado por codigo");
			System.out.println("4. Eliminar empleado");
			System.out.println("5. Salir");
			System.out.println("Escoger opcion:");
			
			try {
				menu=Integer.parseInt(entrada.nextLine());
				gestionarMenu(menu);
			}catch(NumberFormatException e) {
				System.err.println("Formato de menu invalido, introducelo de nuevo");
			}
		}while(menu!=5);
		
	}
	
	private void gestionarMenu(int menu) {
		switch(menu) {
		case 1 -> listaEmpleados=empleado.agregarEmpleado(entrada, listaEmpleados);
		case 2 -> empleado.listarEmpleados(listaEmpleados);
		case 3 -> empleado.buscarEmpleados(entrada, listaEmpleados);
		case 4 -> System.out.println();
		case 5 -> {
			System.out.println("Saliendo del programa ...");
			entrada.close();
			
		}
		default -> System.out.println("Opcion no contemplada, introducela de nuevo");
		}
	}
}

Ejercicio 2

Crea un programa en Java que gestione las calificaciones de los estudiantes utilizando la clase TreeMap. En este caso: La clave será el código único de cada estudiante (un número entero). El valor será un objeto de una clase Estudiante que almacene el nombre y la calificación del estudiante. El programa debe permitir realizar las siguientes operaciones: Agregar estudiante y calificación: Solicita al usuario un código único para el estudiante. Si el código ya existe, informa y no lo permite. Solicita el nombre del estudiante y su calificación para almacenarlos. Eliminar estudiante: Permite eliminar a un estudiante dado su código único. Si el código no existe, informa al usuario. Consultar estudiante por código: Solicita un código y muestra el nombre y la calificación del estudiante. Si no existe, informa al usuario. Listar estudiantes: Muestra todos los estudiantes registrados, ordenados por su código, incluyendo su nombre y calificación. Mostrar estudiante con la calificación más alta: Indica el estudiante con la mayor calificación y su código. Si hay un empate, muestra a cualquiera de los estudiantes con la calificación más alta. Mostrar el promedio de calificaciones: Calcula y muestra el promedio de las calificaciones de todos los estudiantes registrados. Salir del programa: Termina la ejecución. Clase Estudiante: Atributos: String nombre double calificacion Métodos: Constructor para inicializar los atributos. Métodos getters y setters. Un método toString() que devuelva una representación legible del estudiante (nombre y calificación). Consideraciones adicionales: Valida que las calificaciones sean números entre 0 y 10. Asegúrate de que los códigos no se repitan. Agrega mensajes adecuados para guiar al usuario en cada operación.

package treemap;

import java.util.Scanner;
import java.util.TreeMap;

public class Ejercicio2 {

    public static void main(String[] args) {
        MenuEjercicio2 menu = new MenuEjercicio2();
        menu.MostrarMenu(); // Llamada al método para mostrar el menú principal del programa.
    }

}

/* Clase Estudiante: representa la información de un estudiante. */
class Estudiante {
    String nombre; // Almacena el nombre del estudiante.
    double calificacion; // Almacena la calificación del estudiante.

    /* Constructor por defecto. */
    public Estudiante() {}

    /* Constructor para inicializar los atributos nombre y calificación. */
    public Estudiante(String nombre, double calificacion) {
        this.nombre = nombre;
        this.calificacion = calificacion;
    }

    /* Métodos getter y setter para acceder y modificar los atributos. */
    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public double getCalificacion() {
        return calificacion;
    }

    public void setCalificacion(double calificacion) {
        this.calificacion = calificacion;
    }

    /* Método toString para devolver una representación en texto del estudiante. */
    @Override
    public String toString() {
        return "\nNombre ->" + nombre + "\nCalificacion ->" + calificacion;
    }

    /* Solicita y valida un código único para el estudiante. */
    private int agregarCodigo(Scanner entrada) {
        int codigo = 0;
        while (true) {
            try {
                System.out.println("Introduce el codigo de estudiante:");
                codigo = Integer.parseInt(entrada.nextLine());
                if (codigo < 1) {
                    System.out.println("El codigo de estudiante tiene que ser un numero entero positivo");
                } else {
                    return codigo; // Devuelve el código si es válido.
                }
            } catch (NumberFormatException e) {
                System.err.println("Formato de codigo no valido, introducelo de nuevo");
            }
        }
    }

    /* Solicita y valida el nombre del estudiante. */
    private String agregarNombre(Scanner entrada) {
        while (true) {
            System.out.println("Introduce el nombre del estudiante:");
            this.nombre = entrada.nextLine();
            if (this.nombre.equals("")) {
                System.out.println("El nombre de estudiante no puede quedar en blanco, introducelo de nuevo");
            } else {
                return this.nombre; // Devuelve el nombre si es válido.
            }
        }
    }

    /* Solicita y valida la calificación del estudiante (entre 0 y 10). */
    private double agregarCalificacion(Scanner entrada) {
        while (true) {
            try {
                System.err.println("Introduce la calificacion del estudiante");
                this.calificacion = Double.parseDouble(entrada.nextLine());
                if (this.calificacion < 0 || this.calificacion > 10) {
                    System.out.println("La calificacion tiene que ser entre 0 y 10, introducela de nuevo");
                } else {
                    return this.calificacion; // Devuelve la calificación si es válida.
                }
            } catch (NumberFormatException e) {
                System.err.println("Formato de calificacion no valido, introducelo de nuevo");
            }
        }
    }

    /* Crea y devuelve un nuevo objeto Estudiante con datos ingresados por el usuario. */
    private Estudiante agregarEstudiante(Scanner entrada) {
        this.nombre = agregarNombre(entrada);
        this.calificacion = agregarCalificacion(entrada);
        return new Estudiante(this.nombre, this.calificacion);
    }

    /* Método para agregar un estudiante a la lista validando que el código sea único. */
    public TreeMap<Integer, Estudiante> agregarEstudiante(Scanner entrada, TreeMap<Integer, Estudiante> listaEstudiantes) {
        int codigo = 0;
        do {
            codigo = agregarCodigo(entrada);
            if (listaEstudiantes.containsKey(codigo)) {
                System.out.println("El codigo ya esta en uso, introducelo de nuevo");
            }
        } while (listaEstudiantes.containsKey(codigo) || codigo == 0);

        Estudiante estudiante = agregarEstudiante(entrada);
        listaEstudiantes.put(codigo, estudiante); // Agrega el estudiante al TreeMap.
        System.out.println("Estudiante agregado a la lista con exito");
        return listaEstudiantes;
    }

    /* Método para eliminar un estudiante dado su código. */
    public TreeMap<Integer, Estudiante> eliminarEstudiante(Scanner entrada, TreeMap<Integer, Estudiante> listaEstudiantes) {
        if (listaEstudiantes.isEmpty()) {
            System.out.println("La lista de estudiantes esta vacia");
        } else {
            int codigo = agregarCodigo(entrada);
            if (!listaEstudiantes.containsKey(codigo)) {
                System.out.println("El codigo no pertenece a ningun estudiante");
            } else {
                char respuesta;
                while (true) {
                    System.out.println("¿Seguro que quieres borrar al estudiante " + listaEstudiantes.get(codigo) + " (s)(n)");
                    respuesta = entrada.nextLine().toLowerCase().charAt(0);
                    if (respuesta != 's' && respuesta != 'n') {
                        System.out.println("La respuesta tiene que ser (s) o (n)");
                    } else {
                        break;
                    }
                }
                if (respuesta == 's') {
                    listaEstudiantes.remove(codigo); // Elimina al estudiante.
                    System.out.println("Estudiante borrado con éxito");
                    System.out.println("Quedan " + listaEstudiantes.size() + " estudiantes en el curso");
                } else {
                    System.out.println("Operación de borrado de estudiantes abortada");
                }
            }
        }
        return listaEstudiantes;
    }

    /* Consulta y muestra los datos de un estudiante por su código. */
    public void consultarEstudiante(Scanner entrada, TreeMap<Integer, Estudiante> listaEstudiantes) {
        if (listaEstudiantes.isEmpty()) {
            System.out.println("La lista de estudiantes esta vacia");
        } else {
            int codigo = agregarCodigo(entrada);
            if (!listaEstudiantes.containsKey(codigo)) {
                System.out.println("El codigo no corresponde a ningun estudiante");
            } else {
                System.out.println("Codigo -> " + codigo + listaEstudiantes.get(codigo).toString());
            }
        }
    }

    /* Muestra la lista completa de estudiantes en orden por su código. */
    public void listarEstudiante(Scanner entrada, TreeMap<Integer, Estudiante> listaEstudiantes) {
        if (listaEstudiantes.isEmpty()) {
            System.out.println("La lista de estudiantes esta vacia");
        } else {
            System.out.println("Lista completa de estudiantes");
            for (Integer codigo : listaEstudiantes.keySet()) {
                System.out.println("Codigo -> " + codigo + listaEstudiantes.get(codigo).toString());
            }
        }
    }

    /* Calcula y muestra el promedio de las calificaciones de todos los estudiantes. */
    public void promedioEstudiante(Scanner entrada, TreeMap<Integer, Estudiante> listaEstudiantes) {
        if (listaEstudiantes.isEmpty()) {
            System.out.println("La lista de estudiantes esta vacia");
        } else {
            double sumaMedia = 0;
            for (Integer codigo : listaEstudiantes.keySet()) {
                sumaMedia += listaEstudiantes.get(codigo).getCalificacion();
            }
            System.out.println("La nota media de los estudiantes es " + String.format("%.2f", sumaMedia / listaEstudiantes.size()));
        }
    }

    /* Encuentra y muestra el estudiante con la calificación más alta. */
    public void mejorEstudiante(Scanner entrada, TreeMap<Integer, Estudiante> listaEstudiantes) {
        if (listaEstudiantes.isEmpty()) {
            System.out.println("La lista de estudiantes esta vacia");
        } else {
            double notaAlta = Double.MIN_VALUE;
            for (Integer codigo : listaEstudiantes.keySet()) {
                if (listaEstudiantes.get(codigo).getCalificacion() > notaAlta) {
                    notaAlta = listaEstudiantes.get(codigo).getCalificacion();
                }
            }
            for (Integer codigo : listaEstudiantes.keySet()) {
                if (notaAlta == listaEstudiantes.get(codigo).getCalificacion()) {
                    System.out.println("Codigo -> " + codigo + listaEstudiantes.get(codigo).toString());
                }
            }
        }
    }
}

/* Clase MenuEjercicio2: gestiona el menú principal del programa y sus opciones. */
class MenuEjercicio2 {

    TreeMap<Integer, Estudiante> listaEstudiantes = new TreeMap<>();
    Estudiante estudiante = new Estudiante();
    Scanner entrada = new Scanner(System.in);
    int menu = 0;

    /* Muestra el menú principal del programa y gestiona las opciones del usuario. */
    public void MostrarMenu() {
        do {
            System.out.println("Menu Estudiantes");
            System.out.println("1.Agregar estudiante");
            System.out.println("2.Eliminar estudiante");
            System.out.println("3.Consultar estudiante por codigo");
            System.out.println("4.Listar estudiantes");
            System.out.println("5.Mejor estudiante");
            System.out.println("6.Media calificaciones");
            System.out.println("7.Salir");
            System.out.println("Escoge opcion:");
            try {
                menu = Integer.parseInt(entrada.nextLine());
                gestionarMenu(menu); // Llama al método para procesar la opción del menú.
            } catch (NumberFormatException e) {
                System.out.println("Opcion incorrecta");
            }
        } while (menu != 7);
    }

    /* Procesa las opciones seleccionadas por el usuario en el menú. */
    private void gestionarMenu(int opcion) {
        switch (opcion) {
            case 1 -> listaEstudiantes = estudiante.agregarEstudiante(entrada, listaEstudiantes);
            case 2 -> listaEstudiantes = estudiante.eliminarEstudiante(entrada, listaEstudiantes);
            case 3 -> estudiante.consultarEstudiante(entrada, listaEstudiantes);
            case 4 -> estudiante.listarEstudiante(entrada, listaEstudiantes);
            case 5 -> estudiante.mejorEstudiante(entrada, listaEstudiantes);
            case 6 -> estudiante.promedioEstudiante(entrada, listaEstudiantes);
            case 7 -> System.out.println("Adios");
            default -> System.out.println("Opcion incorrecta");
        }
    }
}

Ejercicio 3

Imagina que eres el encargado de desarrollar un sistema para gestionar el inventario de una tienda. El inventario debe almacenar información sobre los productos organizados por su código único. Cada producto tiene las siguientes características: Código único del producto (clave del TreeMap). Nombre del producto. Precio del producto. Cantidad disponible en el inventario. El programa debe permitir realizar las siguientes operaciones: Agregar un producto al inventario. Validar que el código del producto sea único. Si el producto ya existe, informar al usuario y permitirle actualizar el precio y/o la cantidad. Eliminar un producto del inventario. Solicitar el código del producto. Si no existe, informar al usuario. Consultar un producto por su código. Mostrar la información completa del producto (nombre, precio, cantidad). Listar todos los productos del inventario. Mostrar los productos ordenados por su código en formato legible. Mostrar el producto más caro. Indicar el nombre y el precio del producto más caro en el inventario. Calcular el valor total del inventario. Multiplicar el precio de cada producto por la cantidad y sumar los valores de todos los productos. El programa debe utilizar un TreeMap para gestionar el inventario. Además, incluye validaciones necesarias para evitar errores al introducir datos y utiliza un menú interactivo para realizar las operaciones.

package treemap;

import java.util.Scanner;
import java.util.TreeMap;

public class Ejercicio3 {
    public static void main(String[] args) {
        MenuEjercicio3 menu = new MenuEjercicio3();
        menu.mostrarMenu();
    }
}

// Clase Producto que almacena los atributos y comportamientos de un producto
class Producto {
    // Atributos principales del producto
    String nombre; // Nombre del producto
    double precio; // Precio del producto
    int stock;     // Cantidad disponible en el inventario

    // Constructor vacío
    public Producto() {}

    // Constructor para inicializar un producto con sus datos
    public Producto(String nombre, double precio, int stock) {
        this.nombre = nombre;
        this.precio = precio;
        this.stock = stock;
    }

    // Métodos getter y setter para acceder y modificar los atributos del producto
    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public double getPrecio() {
        return precio;
    }

    public void setPrecio(double precio) {
        this.precio = precio;
    }

    public int getStock() {
        return stock;
    }

    public void setStock(int stock) {
        this.stock = stock;
    }

    // Sobrescritura del método toString para representar el producto en formato legible
    @Override
    public String toString() {
        return "\nNombre -> " + nombre + 
               "\nP.V.P -> " + String.format("%.2f", precio) + "€" +
               "\nStock -> " + stock;
    }

    // Método privado para validar y agregar el nombre de un producto
    private String campoNombre(Scanner entrada) {
        while (true) {
            System.out.println("Introduce el nombre del producto:");
            this.nombre = entrada.nextLine();
            if (nombre.trim().isEmpty()) {
                System.out.println("El nombre del producto no puede quedar en blanco. Inténtalo de nuevo.");
            } else {
                return this.nombre;
            }
        }
    }

    // Método privado para validar y agregar el precio del producto
    private double agregarPrecio(Scanner entrada) {
        while (true) {
            try {
                System.out.println("Introduce el precio del producto:");
                this.precio = Double.parseDouble(entrada.nextLine());
                if (this.precio < 0.01) {
                    System.out.println("El precio no puede ser inferior a 1 céntimo. Inténtalo de nuevo.");
                } else {
                    return this.precio;
                }
            } catch (NumberFormatException e) {
                System.err.println("Formato de precio no válido. Inténtalo de nuevo.");
            }
        }
    }

    // Método privado para validar y agregar un entero (código o stock)
    private int agregarEntero(Scanner entrada, String campo) {
        int dato = 0;
        while (true) {
            try {
                System.out.println("Introduce el " + campo + " del producto:");
                dato = Integer.parseInt(entrada.nextLine());
                if (dato < 0) {
                    System.out.println("El " + campo + " no puede ser negativo. Inténtalo de nuevo.");
                } else {
                    return dato;
                }
            } catch (NumberFormatException e) {
                System.err.println("Formato de " + campo + " no válido. Inténtalo de nuevo.");
            }
        }
    }

    // Método para agregar un producto al inventario solicitando todos sus datos
    private Producto agregarProducto(Scanner entrada) {
        this.nombre = campoNombre(entrada);
        this.precio = agregarPrecio(entrada);
        this.stock = agregarEntero(entrada, "stock");
        return new Producto(this.nombre, this.precio, this.stock);
    }

    // Método para eliminar un producto de la lista
    public TreeMap<Integer, Producto> eliminarProductoLista(Scanner entrada, TreeMap<Integer, Producto> listaProductos) {
        if (listaProductos.isEmpty()) {
            System.out.println("Aún no hay productos dados de alta.");
        } else {
            int codigo = agregarEntero(entrada, "código");
            if (!listaProductos.containsKey(codigo)) {
                System.out.println("El código no corresponde a ningún producto de nuestro inventario.");
            } else {
                char respuesta;
                while (true) {
                    System.out.println("¿Seguro que quieres borrar el producto " + listaProductos.get(codigo) + " (s/n)?");
                    respuesta = entrada.nextLine().toLowerCase().charAt(0);
                    if (respuesta != 's' && respuesta != 'n') {
                        System.out.println("La respuesta tiene que ser (s) o (n).");
                    } else {
                        break;
                    }
                }
                if (respuesta == 's') {
                    listaProductos.remove(codigo); // Elimina el producto.
                    System.out.println("Producto borrado con éxito.");
                    System.out.println("Quedan " + listaProductos.size() + " productos en el inventario.");
                } else {
                    System.out.println("Operación de borrado cancelada.");
                }
            }
        }
        return listaProductos;
    }

    // Método para consultar un producto por su código
    public void consultarProductoCodigo(Scanner entrada, TreeMap<Integer, Producto> listaProductos) {
        if (listaProductos.isEmpty()) {
            System.out.println("Aún no hay productos dados de alta.");
        } else {
            int codigo = agregarEntero(entrada, "código");
            if (listaProductos.containsKey(codigo)) {
                System.out.println("Código -> " + codigo + listaProductos.get(codigo).toString());
            } else {
                System.out.println("El código introducido no corresponde a ningún producto del inventario.");
            }
        }
    }

    // Método para listar todos los productos del inventario
    public void listarInventario(TreeMap<Integer, Producto> listaProductos) {
        if (listaProductos.isEmpty()) {
            System.out.println("Aún no hay productos dados de alta.");
        } else {
            System.out.println("Listado de productos en el inventario:");
            int sumaStock = 0;
            for (Integer codigo : listaProductos.keySet()) {
                System.out.println("Código -> " + codigo + listaProductos.get(codigo).toString());
                sumaStock += listaProductos.get(codigo).getStock();
            }
            System.out.println("Hay un total de " + listaProductos.size() + " productos diferentes en el inventario.");
            System.out.println("Hay un total de " + sumaStock + " unidades de producto en el inventario.");
        }
    }

    // Método para calcular el valor total del inventario
    public void valorInventario(TreeMap<Integer, Producto> listaProductos) {
        if (listaProductos.isEmpty()) {
            System.out.println("Aún no hay productos dados de alta.");
        } else {
            double sumaValor = 0;
            for (Integer codigo : listaProductos.keySet()) {
                sumaValor += listaProductos.get(codigo).getStock() * listaProductos.get(codigo).getPrecio();
            }
            System.out.println("El valor total del inventario asciende a -> " + String.format("%.2f", sumaValor) + "€");
        }
    }

    // Método para mostrar el producto más caro del inventario
    public void productoMasCaro(TreeMap<Integer, Producto> listaProductos) {
        if (listaProductos.isEmpty()) {
            System.out.println("Aún no hay productos dados de alta.");
        } else {
            // Determinar el precio más alto usando Streams
            double maxPrecio = listaProductos.values().stream()
                    .mapToDouble(Producto::getPrecio)
                    .max()
                    .orElse(Double.MIN_VALUE);

            // Filtrar los productos que tienen el precio más alto
            long cantidadCaros = listaProductos.values().stream()
                    .filter(producto -> producto.getPrecio() == maxPrecio)
                    .peek(producto -> System.out.println(producto.toString()))
                    .count();

            if (cantidadCaros == 1) {
                System.out.println("Hay un producto que es el más caro.");
            } else {
                System.out.println("Hay " + cantidadCaros + " productos que comparten el precio más caro.");
            }
        }
    }

    // Método para agregar un producto a la lista validando su código
    public TreeMap<Integer, Producto> agregarProductoLista(Scanner entrada, TreeMap<Integer, Producto> listaProductos) {
        int codigo;
        do {
            codigo = agregarEntero(entrada, "código");
            if (listaProductos.containsKey(codigo)) {
                System.out.println("El código de producto ya existe. Introdúcelo de nuevo.");
            } else {
                listaProductos.put(codigo, agregarProducto(entrada));
                System.out.println("Producto agregado correctamente.");
            }
        } while (listaProductos.containsKey(codigo));
        return listaProductos;
    }
}

class MenuEjercicio3{
	TreeMap<Integer,Producto> listaProductos=new TreeMap<Integer,Producto>();
	Producto producto=new Producto();
	Scanner entrada=new Scanner(System.in);
	int menu=0;
	
	
	public void mostrarMenu() {
		do {
			System.out.println("Menu Productos");
			System.out.println("1.Añadir producto");
			System.out.println("2.Eliminar producto");
			System.out.println("3.Consultar producto por codigo");
			System.out.println("4.Listar inventario");
			System.out.println("5.Mostrar producto mas caro");
			System.out.println("6.Valor total del inventario");
			System.out.println("7.Salir del programa");
			System.out.println("Escoger opcion:");
			
			try {
				menu=Integer.parseInt(entrada.nextLine());
				gestionarMenu(menu);
			}catch(NumberFormatException e) {
				System.err.println("Formato de menu no valido, introducelo de nuevo");
			}
		}while(menu!=7);
	}
	
	private void gestionarMenu(int menu) {
		switch(menu) {
		case 1 -> listaProductos=producto.agregarProductoLista(entrada, listaProductos);
		case 2 -> listaProductos=producto.eliminarProductoLista(entrada, listaProductos);
		case 3 -> producto.consultarProductoCodigo(entrada, listaProductos);
		case 4 -> producto.listarInventario(listaProductos);
		case 5 -> producto.productoMasCaro(listaProductos);
		case 6 -> producto.valorInventario(listaProductos);
		case 7 -> {
			System.out.println("Saliendo del programa...");
			entrada.close();
		}
		default -> System.out.println("Opcion no contemplada en el menu, introducela de nuevo");
		}
	}
	
}

Ejercicio 4

Tienes un TreeMap precargado que contiene información sobre las ventas mensuales de una empresa. Las claves son los meses del año (String), y los valores son los ingresos generados en ese mes (Double). Operaciones a realizar: Calcular el ingreso total anual. Determinar el mes con los ingresos más altos. Determinar el mes con los ingresos más bajos. Generar un informe que muestre cada mes junto con su ingreso y su porcentaje sobre el total anual. Obtener la diferencia entre el ingreso más alto y el más bajo. TreeMap ventasMensuales = new TreeMap<>(); ventasMensuales.put("Enero", 2500.0); ventasMensuales.put("Febrero", 3000.0); ventasMensuales.put("Marzo", 2800.0); ventasMensuales.put("Abril", 3200.0); ventasMensuales.put("Mayo", 2700.0); ventasMensuales.put("Junio", 3400.0); ventasMensuales.put("Julio", 3600.0); ventasMensuales.put("Agosto", 4000.0); ventasMensuales.put("Septiembre", 3100.0); ventasMensuales.put("Octubre", 2900.0); ventasMensuales.put("Noviembre", 3300.0); ventasMensuales.put("Diciembre", 3700.0);

package treemap;

import java.util.TreeMap;

public class Ejercicio4 {

	public static void main(String[] args) {
		// Inicialización del TreeMap con los datos de las ventas mensuales
		TreeMap<String, Double> ventasMensuales = new TreeMap<String,Double>();
		ventasMensuales.put("Enero", 2500.0);
		ventasMensuales.put("Febrero", 3000.0);
		ventasMensuales.put("Marzo", 2800.0);
		ventasMensuales.put("Abril", 3200.0);
		ventasMensuales.put("Mayo", 2700.0);
		ventasMensuales.put("Junio", 3400.0);
		ventasMensuales.put("Julio", 3600.0);
		ventasMensuales.put("Agosto", 4000.0);
		ventasMensuales.put("Septiembre", 3100.0);
		ventasMensuales.put("Octubre", 2900.0);
		ventasMensuales.put("Noviembre", 3300.0);
		ventasMensuales.put("Diciembre", 3700.0);

		// Variables para calcular el total anual, el mes con mayores ingresos y el mes con menores ingresos
		Double sumaTotal = 0.0; // Suma total de las ventas anuales
		String mesAlto = "", mesBajo = ""; // Mes con mayores y menores ingresos
		Double mesA = Double.MIN_VALUE, mesB = Double.MAX_VALUE; // Valores más altos y más bajos registrados

		// Iteración a través del TreeMap para calcular los valores requeridos
		for (String mes : ventasMensuales.keySet()) {
			sumaTotal += ventasMensuales.get(mes); // Sumar las ventas del mes al total anual
			
			// Comprobar si el ingreso del mes actual es mayor que el ingreso máximo registrado
			if(ventasMensuales.get(mes) > mesA) {
				mesA = ventasMensuales.get(mes);
				mesAlto = mes; // Actualizar el mes con mayores ingresos
			}
			
			// Comprobar si el ingreso del mes actual es menor que el ingreso mínimo registrado
			if(ventasMensuales.get(mes) < mesB) {
				mesB = ventasMensuales.get(mes);
				mesBajo = mes; // Actualizar el mes con menores ingresos
			}
		}

		// Mostrar el total de ventas anuales
		System.out.println("El total de ventas anuales es " + String.format("%.2f", sumaTotal) + "€");
		// Mostrar el mes con mayores ingresos y su valor
		System.out.println("El mes mas alto es " + mesAlto + " con unas ventas de " + ventasMensuales.get(mesAlto) + "€");
		// Mostrar el mes con menores ingresos y su valor
		System.out.println("El mes mas bajo es " + mesBajo + " con unas ventas de " + ventasMensuales.get(mesBajo) + "€");
		// Mostrar la diferencia entre los ingresos más altos y los más bajos
		System.out.println("La diferencia entre el mes alto y el mes mas bajo es: " + String.format("%.2f", (ventasMensuales.get(mesAlto)-ventasMensuales.get(mesBajo))) + "€");
		
		// Generar un informe con cada mes, su ingreso y el porcentaje que representa sobre el total anual
		for (String mes : ventasMensuales.keySet()) {
			System.out.println("Mes -> " + mes + 
							   " Ventas -> " + ventasMensuales.get(mes) + 
							   " % Anual -> " + String.format("%.2f", ((ventasMensuales.get(mes)*100)/sumaTotal)) + "%");
		}
	}

}

Ejercicio 5

Tienes un TreeMap precargado que contiene información sobre la temperatura promedio mensual de una ciudad en grados Celsius. Las claves son los meses del año (String) y los valores son las temperaturas promedio (Double). Operaciones a realizar: Calcular la temperatura promedio anual. Determinar el mes con la temperatura más alta. Determinar el mes con la temperatura más baja. Generar un informe que muestre cada mes junto con su temperatura y su diferencia respecto a la temperatura promedio anual. Calcular la diferencia entre la temperatura más alta y la más baja. TreeMap temperaturasMensuales = new TreeMap<>(); temperaturasMensuales.put("Enero", 8.5); temperaturasMensuales.put("Febrero", 9.2); temperaturasMensuales.put("Marzo", 12.1); temperaturasMensuales.put("Abril", 15.3); temperaturasMensuales.put("Mayo", 18.6); temperaturasMensuales.put("Junio", 22.4); temperaturasMensuales.put("Julio", 25.0); temperaturasMensuales.put("Agosto", 24.5); temperaturasMensuales.put("Septiembre", 20.3); temperaturasMensuales.put("Octubre", 16.2); temperaturasMensuales.put("Noviembre", 11.3); temperaturasMensuales.put("Diciembre", 8.9);

package treemap;

import java.util.TreeMap;

public class Ejercicio5 {

    public static void main(String[] args) {
        // /* TreeMap precargado con las temperaturas promedio mensuales de una ciudad */
        TreeMap<String, Double> temperaturasMensuales = new TreeMap<>();
        temperaturasMensuales.put("Enero", 8.5);
        temperaturasMensuales.put("Febrero", 9.2);
        temperaturasMensuales.put("Marzo", 12.1);
        temperaturasMensuales.put("Abril", 15.3);
        temperaturasMensuales.put("Mayo", 18.6);
        temperaturasMensuales.put("Junio", 22.4);
        temperaturasMensuales.put("Julio", 25.0);
        temperaturasMensuales.put("Agosto", 24.5);
        temperaturasMensuales.put("Septiembre", 20.3);
        temperaturasMensuales.put("Octubre", 16.2);
        temperaturasMensuales.put("Noviembre", 11.3);
        temperaturasMensuales.put("Diciembre", 8.9);

        // /* Cálculo de la temperatura promedio anual */
        double temperaturaMedia = 0.0;
        for (String mes : temperaturasMensuales.keySet()) {
            temperaturaMedia += temperaturasMensuales.get(mes);
        }

        // /* Encontrar el mes con la temperatura más alta */
        String mesMaxTemperatura = temperaturasMensuales.entrySet().stream()
            .max((t1, t2) -> t1.getValue().compareTo(t2.getValue()))
            .get().getKey();

        // /* Encontrar el mes con la temperatura más baja */
        String mesMinTemperatura = temperaturasMensuales.entrySet().stream()
            .min((t1, t2) -> t1.getValue().compareTo(t2.getValue()))
            .get().getKey();

        // /* Mostrar la temperatura promedio anual */
        System.out.println("La temperatura media es: " + String.format("%.2f", (temperaturaMedia / temperaturasMensuales.size())) + "ºC");

        // /* Mostrar el mes con la temperatura máxima y su valor */
        System.out.println("El mes con la temperatura máxima fue " + mesMaxTemperatura + " con una temperatura de " + temperaturasMensuales.get(mesMaxTemperatura) + "ºC");

        // /* Mostrar el mes con la temperatura mínima y su valor */
        System.out.println("El mes con la temperatura mínima fue " + mesMinTemperatura + " con una temperatura de " + temperaturasMensuales.get(mesMinTemperatura) + "ºC");

        // /* Calcular y mostrar la diferencia de cada mes respecto a la temperatura promedio */
        temperaturaMedia = temperaturaMedia / temperaturasMensuales.size();
        for (String mes : temperaturasMensuales.keySet()) {
            System.out.println("Mes:" + mes + " Temperatura: " + temperaturasMensuales.get(mes) + "ºC" + 
                " Diferencia Media: " + String.format("%.2f", (temperaturasMensuales.get(mes) - temperaturaMedia)) + "ºC");
        }

        // /* Mostrar la diferencia entre la temperatura más alta y más baja */
        System.out.println("La diferencia entre el mes más cálido y el mes más frío es: " + 
            String.format("%.2f", (temperaturasMensuales.get(mesMaxTemperatura) - temperaturasMensuales.get(mesMinTemperatura))) + "ºC");
    }
}