Carlos Fernández García

Ejercicio 1

Crea un programa en Java que almacene las calificaciones de los estudiantes en un HashMap. El programa debe: Permitir al usuario ingresar el nombre de un estudiante y su calificación. Permitir al usuario buscar la calificación de un estudiante por su nombre. Mostrar todas las calificaciones ingresadas.

package hashmap;

import java.util.HashMap;
import java.util.Scanner;

public class Ejercicio1 {

    public static void main(String[] args) {
        // Crear una instancia de MenuEjercicio1 y mostrar el menú al usuario
        MenuEjercicio1 menu = new MenuEjercicio1();
        menu.mostrarMenu();
    }
}

class MenuEjercicio1 {
    // Mapa para almacenar estudiantes y sus calificaciones
    HashMap<String, Double> estudiantes = new HashMap<>(); 
    Scanner entrada = new Scanner(System.in); // Scanner para leer la entrada del usuario
    int menu = 0; // Variable para almacenar la opción del menú seleccionada

    // Método para mostrar el menú y gestionar las opciones
    public void mostrarMenu() {
        do {
            // Mostrar las opciones del menú
            System.out.println("Menu estudiantes");
            System.out.println("1. Agregar estudiante y nota");
            System.out.println("2. Buscar estudiante y nota");
            System.out.println("3. Mostrar estudiantes y notas");
            System.out.println("4. Salir");
            System.out.print("Escoge opción: "); // Usar print para mantener el cursor en la misma línea

            try {
                // Leer la opción seleccionada por el usuario
                menu = Integer.parseInt(entrada.nextLine());
                gestionarMenu(menu); // Llamar al método que gestiona la opción seleccionada
            } catch (NumberFormatException e) {
                // Manejo de excepción si la entrada no es un número válido
                System.err.println("Formato de menú no válido, introdúcelo de nuevo");
            }
        } while (menu != 4); // Repetir hasta que el usuario elija salir
    }

    // Método para solicitar y validar el nombre del estudiante
    private String nombreEstudiante() {
        String nombre;
        while (true) {
            System.out.print("Introduce el nombre del estudiante: "); // Usar print para mantener el cursor en la misma línea
            nombre = entrada.nextLine();
            if (nombre.equals("")) {
                System.out.println("El nombre no puede quedar vacío, introdúcelo de nuevo");
            } else {
                return nombre; // Retornar el nombre válido
            }
        }
    }

    // Método para solicitar y validar la calificación del estudiante
    private Double notaEstudiante() {
        Double nota = 0.0;
        while (true) {
            try {
                System.out.print("Introduce la calificación del estudiante: "); // Usar print para mantener el cursor en la misma línea
                nota = Double.parseDouble(entrada.nextLine());
                // Validar que la calificación esté en el rango de 0 a 10
                if (nota < 0 || nota > 10) {
                    System.out.println("La nota del estudiante tiene que estar comprendida entre 0 y 10, introdúcela de nuevo");
                } else {
                    return nota; // Retornar la nota válida
                }
            } catch (NumberFormatException e) {
                // Manejo de excepción si la entrada no es un número válido
                System.err.println("Formato de calificación no válido, introdúcelo de nuevo");
            }
        }
    }

    // Método para agregar un estudiante y su calificación al HashMap
    private void agregarEstudiante() {
        String nombre = nombreEstudiante(); // Obtener el nombre del estudiante
        Double nota = notaEstudiante(); // Obtener la calificación del estudiante

        // Comprobar si el estudiante ya está en el HashMap
        if (estudiantes.containsKey(nombre)) {
            System.out.println("El estudiante ya está dado de alta");
        } else {
            // Agregar el estudiante y su calificación al HashMap
            estudiantes.put(nombre, nota);
            System.out.println("Estudiante dado de alta correctamente");
        }
    }

    // Método para buscar la calificación de un estudiante por su nombre
    private void buscarEstudiante() {
        // Verificar si hay estudiantes en el HashMap
        if (estudiantes.isEmpty()) {
            System.out.println("No hay estudiantes dados de alta");
        } else {
            String nombre = nombreEstudiante(); // Obtener el nombre del estudiante
            // Comprobar si el estudiante está en el HashMap
            if (estudiantes.containsKey(nombre)) {
                // Mostrar la calificación del estudiante
                System.out.println("La nota del estudiante " + nombre + " es: " + estudiantes.get(nombre));
            } else {
                System.out.println("El estudiante no está dado de alta");
            }
        }
    }

    // Método para mostrar la lista de estudiantes y sus calificaciones
    private void mostrarLista() {
        // Verificar si hay estudiantes en el HashMap
        if (estudiantes.isEmpty()) {
            System.out.println("No hay estudiantes dados de alta");
        } else {
            // Iterar sobre las claves (nombres de estudiantes) del HashMap
            for (String nombre : estudiantes.keySet()) {
                // Mostrar el nombre del estudiante y su calificación
                System.out.println("Estudiante: " + nombre + " | Nota: " + estudiantes.get(nombre));
            }
        }
    }

    // Método para gestionar la opción del menú seleccionada
    private void gestionarMenu(int menu) {
        switch (menu) {
            case 1 -> agregarEstudiante(); // Opción para agregar estudiante
            case 2 -> buscarEstudiante(); // Opción para buscar estudiante
            case 3 -> mostrarLista(); // Opción para mostrar lista de estudiantes
            case 4 -> {
                System.out.println("Saliendo del programa ...");
                entrada.close(); // Cerrar el scanner al salir
            }
            default -> System.out.println("Opción no contemplada, introdúcela de nuevo");
        }
    }
}

Ejercicio 2

Imagina que estás desarrollando un sistema para gestionar el inventario de una tienda. Necesitas implementar una clase que use un HashMap para almacenar información sobre los productos de la tienda. Cada producto tiene un código único (clave) y una cantidad (valor). Crea un método para añadir productos al inventario. Si el producto ya existe, actualiza su cantidad sumando la nueva cantidad recibida. Implementa un método que permita eliminar un producto del inventario usando su código. Diseña un método para verificar la existencia de un producto a partir de su código y, en caso de que esté en inventario, devolver su cantidad. Agrega un método para mostrar todos los productos con sus cantidades. (Opcional) Implementa una función para encontrar el producto con la mayor cantidad en el inventario.

package hashmap;

import java.util.Collections;
import java.util.HashMap;
import java.util.Scanner;

public class Ejercicio2 {

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

class Tienda {
	int codigo;
	int cantidad;
	
	// Método para solicitar y validar el código del producto ingresado por el usuario
	private int codigoProducto(Scanner entrada) {
		while (true) {
			try {
				System.out.println("Introduce el código del producto:");
				this.codigo = Integer.parseInt(entrada.nextLine());
				if (this.codigo < 1) {
					System.out.println("El código tiene que ser mayor que 0, introdúcelo de nuevo");
				} else {
					return this.codigo;
				}
			} catch (NumberFormatException e) {
				System.err.println("Formato de código no válido, introdúcelo de nuevo");
			}
		}
	}
	
	// Método para solicitar y validar la cantidad del producto ingresada por el usuario
	private int cantidadProducto(Scanner entrada) {
		while (true) {
			try {
				System.out.println("Introduce la cantidad del producto:");
				this.cantidad = Integer.parseInt(entrada.nextLine());
				if (this.cantidad < 1) {
					System.out.println("La cantidad tiene que ser mayor que 0, introdúcela de nuevo");
				} else {
					return this.cantidad;
				}
			} catch (NumberFormatException e) {
				System.err.println("Formato de cantidad no válido, introdúcelo de nuevo");
			}
		}
	}
	
	// Método para agregar un producto al inventario. Si ya existe, suma la nueva cantidad.
	public HashMap<Integer, Integer> agregarProducto(Scanner entrada, HashMap<Integer, Integer> productos) {
		this.codigo = codigoProducto(entrada);

		if (productos.containsKey(this.codigo)) {
			System.out.println("El producto ya está dado de alta, se sumará la cantidad de stock que introduzcas");
			this.cantidad = cantidadProducto(entrada) + productos.get(this.codigo);
			productos.put(this.codigo, this.cantidad);  // Actualiza el stock del producto existente
			System.out.println("Stock actualizado");
		} else {
			this.cantidad = cantidadProducto(entrada);
			productos.put(this.codigo, this.cantidad);  // Añade un nuevo producto al inventario
			System.out.println("Producto dado de alta correctamente");
		}
		
		return productos;
	}
	
	// Método para eliminar un producto del inventario tras confirmar con el usuario
	public HashMap<Integer, Integer> eliminarProducto(Scanner entrada, HashMap<Integer, Integer> productos) {
		if (productos.isEmpty()) {
			System.out.println("La lista está vacía");
		} else {
			this.codigo = codigoProducto(entrada);
			
			if (!productos.containsKey(this.codigo)) {
				System.out.println("No hay ningún producto con ese código, acción cancelada");
			} else {
				char respuesta = ' ';
				
				// Solicita confirmación antes de borrar el producto
				while (true) {
					System.out.println("¿Estás seguro que quieres borrar el producto con código " + this.codigo + "? (s)(n)");
					respuesta = entrada.next().toLowerCase().charAt(0);
					
					if (respuesta != 's' && respuesta != 'n') {
						System.out.println("La respuesta tiene que ser (s) o (n), introdúcela de nuevo");
					} else {
						break;
					}
				}
				
				if (respuesta == 'n') {
					System.out.println("Acción de borrado cancelada");
				} else {
					productos.remove(this.codigo);  // Elimina el producto del inventario
					System.out.println("Producto borrado correctamente");
				}
			}
		}
		return productos;
	}
	
	// Método para consultar la existencia y cantidad de un producto en el inventario
	public void consultarProducto(Scanner entrada, HashMap<Integer, Integer> productos) {
		if (productos.isEmpty()) {
			System.out.println("La lista está vacía");
		} else {
			this.codigo = codigoProducto(entrada);
			
			if (!productos.containsKey(this.codigo)) {
				System.out.println("El código del producto no se encuentra");
			} else {
				System.out.println("El producto tiene un stock de: " + productos.get(this.codigo));
			}
		}
	}
	
	// Método para mostrar todos los productos en el inventario con sus cantidades
	public void mostrarProductos(HashMap<Integer, Integer> productos) {
		if (productos.isEmpty()) {
			System.out.println("La lista está vacía");
		} else {
			System.out.println("Lista de los productos");
			for (Integer codigo : productos.keySet()) {
				System.out.println("Código: " + codigo + " --> Cantidad: " + productos.get(codigo));
			}
		}
	}

	// Método para encontrar y mostrar el producto(s) con la mayor cantidad en el inventario
	public void mayorCantidad(HashMap<Integer, Integer> productos) {
		if (productos.isEmpty()) {
			System.out.println("La lista está vacía");
		} else {
			int max = Collections.max(productos.values());  // Encuentra el valor máximo de cantidad

			// Muestra todos los productos que tienen la cantidad máxima
			System.out.println("Productos con la mayor cantidad (" + max + "):");
			for (var entry : productos.entrySet()) {
				if (entry.getValue() == max) {
					System.out.println("Código: " + entry.getKey() + " -> Cantidad: " + entry.getValue());
				}
			}
		}
	}
}

class MenuEjercicio2 {
	int menu = 0;
	Scanner entrada = new Scanner(System.in);
	HashMap<Integer, Integer> productos = new HashMap<Integer, Integer>();
	Tienda tienda = new Tienda();
	
	// Método para mostrar y gestionar el menú principal de opciones
	public void mostrarMenu() {
		do {
			System.out.println("Menú tienda");
			System.out.println("1. Añadir producto");
			System.out.println("2. Eliminar producto");
			System.out.println("3. Consultar producto");
			System.out.println("4. Listar productos");
			System.out.println("5. Producto con mayor stock");
			System.out.println("6. Salir");
			System.out.println("Escoge opción:");
			
			try {
				menu = Integer.parseInt(entrada.nextLine());
				gestionarMenu(menu);  // Llama al método que procesa la opción seleccionada
			} catch (NumberFormatException e) {
				System.err.println("Formato de menú no válido, introdúcelo de nuevo");
			}
		} while (menu != 6);
	}
	
	// Método para procesar la opción seleccionada en el menú
	private void gestionarMenu(int menu) {
		switch (menu) {
		case 1 -> productos = tienda.agregarProducto(entrada, productos);
		case 2 -> productos = tienda.eliminarProducto(entrada, productos);
		case 3 -> tienda.consultarProducto(entrada, productos);
		case 4 -> tienda.mostrarProductos(productos);
		case 5 -> tienda.mayorCantidad(productos);
		case 6 -> {
			System.out.println("Saliendo del programa...");
			entrada.close();
			break;
		}
		default -> System.out.println("Opción no contemplada en el menú, introdúcela de nuevo");
		}
	}
}

Ejercicio 3

Imagina que estás desarrollando una agenda de contactos telefónicos en la que los contactos pueden tener nombres repetidos. Cada contacto tiene un número de teléfono (clave) y un nombre (valor). Crea una clase que utilice un HashMap para almacenar esta información y que permita realizar las siguientes operaciones: Añadir un contacto: Si el número ya existe en la agenda, informa al usuario y pregunta si desea actualizar el nombre asociado. Eliminar un contacto: Elimina un contacto dado su número de teléfono. Consultar un contacto: Muestra el nombre asociado a un número de teléfono dado. Si el número no existe en la agenda, informa al usuario. Mostrar todos los contactos: Lista todos los números de teléfono junto con sus nombres asociados. Opcional: Implementa una función que permita buscar contactos cuyos nombres comiencen con una letra o subcadena específica.

package hashmap;

import java.util.HashMap;
import java.util.Scanner;

// Clase principal del programa
public class Ejercicio3 {

    public static void main(String[] args) {
        // Instancia del menú y llamada al método para mostrar opciones
        MenuEjercicio3 menu = new MenuEjercicio3();
        menu.mostrarMenu();
    }
}

// Clase Agenda para gestionar los contactos
class Agenda {
    String numero; // Variable para almacenar el número de teléfono
    String nombre; // Variable para almacenar el nombre del contacto

    // Método para agregar datos solicitando al usuario hasta que el campo no esté vacío
    private String agregarCampo(Scanner entrada, String campo) {
        String dato = "";
        while (true) {
            System.out.println("Introduce el " + campo + " del contacto:");
            dato = entrada.nextLine();
            
            // Verificación de campo vacío
            if (dato.equals("")) {
                System.out.println("El " + campo + " no puede quedar vacio, introducelo de nuevo");
            } else {
                return dato;
            }
        }
    }

    // Método para agregar un contacto a la agenda
    public HashMap<String, String> agregarContacto(Scanner entrada, HashMap<String, String> listaAgenda) {
        this.numero = agregarCampo(entrada, "numero");
        
        // Verifica si el número ya existe en la agenda
        if (listaAgenda.containsKey(this.numero)) {
            System.out.println("El numero ya esta en la agenda");
        } else {
            this.nombre = agregarCampo(entrada, "nombre");
            listaAgenda.put(numero, nombre);
            System.out.println("Contacto agregado correctamente a la agenda");
        }
        
        return listaAgenda;
    }

    // Método para listar todos los contactos almacenados
    public void listarContactos(HashMap<String, String> listaAgenda) {
        if (listaAgenda.isEmpty()) {
            System.out.println("No hay numeros todavia en la agenda");
            return;
        } else {
            System.out.println("Lista completa de contactos");
            
            // Iteración sobre los contactos en el HashMap
            for (String numero : listaAgenda.keySet()) {
                System.out.println("Nombre: " + listaAgenda.get(numero) + " Tlf:" + numero);
            }
        }
    }

    // Método para listar contactos que comienzan con una letra específica
    public void listarContactosFiltrado(Scanner entrada, HashMap<String, String> listaAgenda) {
        if (listaAgenda.isEmpty()) {
            System.out.println("No hay numeros todavia en la agenda");
            return;
        } else {
            char letra = ' ';
            
            // Solicita la letra inicial hasta que sea válida
            while (true) {
                System.out.println("Introduce la letra de la agenda:");
                letra = entrada.nextLine().toLowerCase().charAt(0);
                
                if (letra == ' ' || letra < 'a' || letra > 'z') {
                    System.out.println("La letra tiene que ser entre a y z");
                } else {
                    break;
                }
            }
            
            boolean encontrado = false;
            // Filtra y muestra los contactos cuyo nombre comienza con la letra especificada
            for (String numero : listaAgenda.keySet()) {
                if (listaAgenda.get(numero).charAt(0) == letra) {
                    System.out.println("Nombre: " + listaAgenda.get(numero) + " Tlf:" + numero);
                    encontrado = true;
                }
            }
            if (!encontrado) {
                System.out.println("No hay contactos que empiecen por " + letra);
            }
        }
    }

    // Método para buscar un contacto por su número
    public void buscarContacto(Scanner entrada, HashMap<String, String> listaAgenda) {
        if (listaAgenda.isEmpty()) {
            System.out.println("No hay numeros todavia en la agenda");
            return;
        } else {
            this.numero = agregarCampo(entrada, "numero");
            
            // Verifica la existencia del número en la agenda
            if (!listaAgenda.containsKey(this.numero)) {
                System.out.println("El numero no se encuentra en la agenda");
            } else {
                System.out.println("El numero " + this.numero + " corresponde a " + listaAgenda.get(this.numero));
            }
        }
    }

    // Método para eliminar un contacto de la agenda
    public HashMap<String, String> eliminarContacto(Scanner entrada, HashMap<String, String> listaAgenda) {
        if (listaAgenda.isEmpty()) {
            System.out.println("No hay numeros todavia en la agenda");
            return listaAgenda;
        } else {
            this.numero = agregarCampo(entrada, "numero");
            
            // Verifica la existencia del número antes de intentar eliminarlo
            if (!listaAgenda.containsKey(this.numero)) {
                System.out.println("El numero no se encuentra en la agenda");
            } else {
                char respuesta = ' ';
                while (true) {
                    System.out.println("¿Estas seguro que quieres borrar el numero " + this.numero + "?(s)(n)");
                    respuesta = entrada.nextLine().toLowerCase().charAt(0);
                    
                    if (respuesta != 's' && respuesta != 'n') {
                        System.out.println("La respuesta tiene que ser (s) o (n), introducela de nuevo");
                    } else {
                        break;
                    }
                }
                
                // Elimina el contacto si el usuario confirma la acción
                if (respuesta == 'n') {
                    System.out.println("Accion de borrado cancelada");
                } else {
                    listaAgenda.remove(this.numero);
                    System.out.println("Contacto borrado con exito");
                }
            }
            return listaAgenda;
        }
    }
}

// Clase para gestionar el menú de opciones de la agenda
class MenuEjercicio3 {
    int menu = 0; // Variable para la opción seleccionada en el menú
    Scanner entrada = new Scanner(System.in); // Scanner para recibir entrada del usuario
    HashMap<String, String> listaAgenda = new HashMap<String, String>(); // Mapa para almacenar los contactos
    Agenda agenda = new Agenda(); // Instancia de la clase Agenda para manipular los contactos
    
    // Método para mostrar el menú de opciones y procesar la selección
    public void mostrarMenu() {
        do {
            System.out.println("AGENDA");
            System.out.println("1. Añadir contacto");
            System.out.println("2. Eliminar contacto");
            System.out.println("3. Consultar contacto");
            System.out.println("4. Listar contactos");
            System.out.println("5. Listar contactos letra");
            System.out.println("6. Salir");
            System.out.println("Escoge 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 != 6);
    }
    
    // Método para gestionar cada opción del menú
    private void gestionarMenu(int menu) {
        switch (menu) {
            case 1 -> listaAgenda = agenda.agregarContacto(entrada, listaAgenda);
            case 2 -> listaAgenda = agenda.eliminarContacto(entrada, listaAgenda);
            case 3 -> agenda.buscarContacto(entrada, listaAgenda);
            case 4 -> agenda.listarContactos(listaAgenda);
            case 5 -> agenda.listarContactosFiltrado(entrada, listaAgenda);
            case 6 -> {
                System.out.println("Saliendo de la agenda ...");
                entrada.close(); // Cierre del Scanner al salir del programa
                break;
            }
            default -> System.out.println("Opcion no contemplada en el menu, introducela de nuevo");
        }
    }
}

Ejercicio 4

Imagina que estás desarrollando una aplicación para gestionar el inventario de una librería. Cada libro tiene un código único (clave) y un título (valor). El programa debe permitir realizar las siguientes operaciones: Añadir un libro: Permite al usuario agregar un libro nuevo al inventario. Si el código ya existe, informa al usuario y pregunta si desea actualizar el título. Eliminar un libro: Permite al usuario eliminar un libro del inventario dado su código. Consultar un libro: Muestra el título asociado a un código de libro dado. Si el código no existe en el inventario, informa al usuario. Mostrar todos los libros: Lista todos los códigos junto con sus títulos en el inventario. Buscar libros por palabra clave: Implementa una función que permita buscar todos los libros cuyo título contenga una palabra o subcadena específica ingresada por el usuario. Contar libros en el inventario: Devuelve la cantidad total de libros en el inventario.

package hashmap;

import java.util.HashMap;
import java.util.Scanner;

public class Ejercicio4 {

    public static void main(String[] args) {
        // Crea una instancia del menú y lo muestra al usuario
        MenuEjercicio4 menu = new MenuEjercicio4();
        menu.mostrarMenu();
    }
}

class Libro {
    int codigo; // Código único del libro
    String titulo; // Título del libro

    // Solicita al usuario el código del libro, validando que sea un número positivo
    private int agregarCodigo(Scanner entrada) {
        while (true) {
            try {
                System.out.println("Introduce el código del libro:");
                this.codigo = Integer.parseInt(entrada.nextLine());
                
                if (this.codigo < 1) {
                    System.out.println("El código no puede ser menor que 1, introdúcelo de nuevo");
                } else {
                    return this.codigo;
                }
            } catch (NumberFormatException e) {
                System.err.println("Formato de código no válido, introdúcelo de nuevo");
            }
        }
    }

    // Solicita al usuario el título del libro, asegurándose de que no esté vacío
    private String agregarTitulo(Scanner entrada) {
        while (true) {
            System.out.println("Introduce el título del libro:");
            this.titulo = entrada.nextLine();
            
            if (this.titulo.equals("")) {
                System.out.println("El título no puede quedar en blanco, introdúcelo de nuevo");
            } else {
                return this.titulo;
            }
        }
    }

    // Agrega un libro al inventario, verificando si el código ya existe
    public HashMap<Integer, String> agregarLibro(Scanner entrada, HashMap<Integer, String> libros) {
        this.codigo = agregarCodigo(entrada);
        
        if (libros.containsKey(this.codigo)) {
            System.out.println("El código del libro ya está dado de alta");
        } else {
            this.titulo = agregarTitulo(entrada);
            libros.put(this.codigo, this.titulo);
            System.out.println("Libro agregado correctamente a la biblioteca");
        }
        
        return libros;
    }

    // Lista todos los libros en el inventario, mostrando el código y título de cada uno
    public void listarLibros(HashMap<Integer, String> libros) {
        if (libros.isEmpty()) {
            System.out.println("No hay libros dados de alta en la biblioteca");
        } else {
            System.out.println("Listado de libros:");
            for (Integer codigo : libros.keySet()) {
                System.out.println("Código: " + codigo + " --> Título: " + libros.get(codigo));
            }
        }
    }

    // Consulta un libro específico según su código, mostrando el título asociado
    public void consultarLibro(Scanner entrada, HashMap<Integer, String> libros) {
        if (libros.isEmpty()) {
            System.out.println("No hay libros dados de alta en la biblioteca");
        } else {
            this.codigo = agregarCodigo(entrada);
            
            if (libros.containsKey(this.codigo)) {
                System.out.println("El código " + this.codigo + " corresponde al libro " + libros.get(this.codigo));
            } else {
                System.out.println("El código no corresponde a ningún libro");
            }
        }
    }

    // Busca libros cuyo título contenga una palabra o subcadena ingresada por el usuario
    public void buscarLibroAvanzado(Scanner entrada, HashMap<Integer, String> libros) {
        if (libros.isEmpty()) {
            System.out.println("No hay libros dados de alta en la biblioteca");
        } else {
            String cadenaBusqueda = agregarTitulo(entrada);
            
            for (Integer codigo : libros.keySet()) {
                if (libros.get(codigo).contains(cadenaBusqueda)) {
                    System.out.println("Código: " + codigo + " --> Título: " + libros.get(codigo));
                }
            }
        }
    }

    // Cuenta y muestra el total de libros en el inventario
    public void totalLibros(HashMap<Integer, String> libros) {
        if (libros.isEmpty()) {
            System.out.println("No hay libros dados de alta en la biblioteca");
        } else {
            System.out.println("La biblioteca cuenta con un total de " + libros.size() + " libros dados de alta");
        }
    }

    // Elimina un libro del inventario según su código, confirmando con el usuario
    public HashMap<Integer, String> eliminarLibro(Scanner entrada, HashMap<Integer, String> libros) {
        if (libros.isEmpty()) {
            System.out.println("No hay libros dados de alta en la biblioteca");
            return libros;
        } else {
            this.codigo = agregarCodigo(entrada);
            
            if (!libros.containsKey(this.codigo)) {
                System.out.println("El código no corresponde a ningún libro");
            } else {
                char respuesta = ' ';
                
                // Confirma si el usuario desea eliminar el libro
                while (true) {
                    System.out.println("¿Estás seguro de borrar el libro " + libros.get(this.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 == 'n') {
                    System.out.println("Operación de borrado abortada");
                } else {
                    libros.remove(this.codigo);
                    System.out.println("Libro borrado con éxito");
                }
            }
        }
        
        return libros;
    }
}

class MenuEjercicio4 {
    HashMap<Integer, String> libros = new HashMap<Integer, String>(); // Mapa de inventario de libros
    Libro libro = new Libro(); // Instancia de la clase Libro
    Scanner entrada = new Scanner(System.in); // Scanner para entrada del usuario
    int menu = 0; // Opción del menú

    // Muestra el menú de opciones al usuario
    public void mostrarMenu() {
        do {
            System.out.println("Biblioteca");
            System.out.println("1. Añadir libro");
            System.out.println("2. Eliminar libro");
            System.out.println("3. Consultar un libro");
            System.out.println("4. Listar libros");
            System.out.println("5. Buscar libros por palabras");
            System.out.println("6. Contar libros");
            System.out.println("7. Salir");
            System.out.println("Escoge opción:");
            
            try {
                menu = Integer.parseInt(entrada.nextLine());
                gestionarMenu(menu);
            } catch (NumberFormatException e) {
                System.err.println("Formato de menú no válido, introdúcelo de nuevo");
            }
        } while (menu != 7);
    }

    // Gestiona la opción seleccionada en el menú
    private void gestionarMenu(int menu) {
        switch (menu) {
            case 1 -> libros = libro.agregarLibro(entrada, libros);
            case 2 -> libros = libro.eliminarLibro(entrada, libros);
            case 3 -> libro.consultarLibro(entrada, libros);
            case 4 -> libro.listarLibros(libros);
            case 5 -> libro.buscarLibroAvanzado(entrada, libros);
            case 6 -> libro.totalLibros(libros);
            case 7 -> {
                System.out.println("Saliendo de la biblioteca...");
                entrada.close(); // Cierra el Scanner al salir
                break;
            }
            default -> System.out.println("Opción no contemplada, introdúcela de nuevo");
        }
    }
}

Ejercicio 5

Imagina que estás desarrollando un sistema para almacenar y gestionar las calificaciones de estudiantes. Cada estudiante tiene un número de identificación único (clave) y un conjunto de asignaturas junto con sus calificaciones (valor). El programa debe permitir realizar las siguientes operaciones: Añadir una asignatura y su calificación a un estudiante: Permite al usuario añadir una nueva asignatura y su calificación a un estudiante específico. Si el estudiante no existe, debe crearlo en el sistema. Actualizar calificación de una asignatura: Permite actualizar la calificación de una asignatura existente para un estudiante. Si la asignatura no existe, muestra un mensaje informando al usuario. Eliminar una asignatura de un estudiante: Dado el número de identificación de un estudiante y el nombre de la asignatura, elimina esa asignatura de su lista. Consultar calificaciones de un estudiante: Muestra todas las asignaturas y sus calificaciones para un estudiante específico. Si el estudiante no existe, informa al usuario. Calcular el promedio de un estudiante: Calcula y muestra el promedio de todas las calificaciones de un estudiante dado. Mostrar todos los estudiantes y sus calificaciones: Lista todos los estudiantes junto con cada asignatura y su respectiva calificación.


package hashmap;

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class Ejercicio5 {

	public static void main(String[] args) {
		MenuEjercicio5 menu=new MenuEjercicio5();
		menu.mostrarMenu();

	}

}

class Estudiante{
	int codigo;
	String nombre;
	String apellido;
	HashMap<Integer, String> asignaturas = new HashMap<>();
	

	HashMap<Integer,Double> notas=new HashMap<Integer,Double>();
	
	public Estudiante() {
		
	}

	public Estudiante(String nombre, String apellido, HashMap<Integer, String> asignaturas,
			HashMap<Integer, Double> notas) {
		this.nombre = nombre;
		this.apellido = apellido;
		this.asignaturas = asignaturas;
		this.notas = notas;
	}

	public int getCodigo() {
		return codigo;
	}

	public void setCodigo(int codigo) {
		this.codigo = codigo;
	}
	
	public String getNombre() {
		return nombre;
	}

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

	public String getApellido() {
		return apellido;
	}

	public void setApellido(String apellido) {
		this.apellido = apellido;
	}

	public HashMap<Integer, String> getAsignaturas() {
		return asignaturas;
	}

	public void setAsignaturas(HashMap<Integer, String> asignaturas) {
		this.asignaturas = asignaturas;
	}

	public HashMap<Integer, Double> getNotas() {
		return notas;
	}

	public void setNotas(HashMap<Integer, Double> notas) {
		this.notas = notas;
	}

	@Override
	public String toString() {
		return "Estudiante codigo=" + codigo + "nombre=" + nombre + ", apellido=" + apellido + ", asignaturas=" + asignaturas + ", notas="
				+ notas + "]";
	}
	
	
	private String campoTexto(Scanner entrada, String campo) {
		String dato="";
		
		while(true) {
			System.out.println("Introduce el " + campo + " del estudiante");
			dato=entrada.nextLine();
			
			if(dato.equals("")) {
				System.out.println("El " + campo + " del estudiante no puede quedar sin rellanar, introducelo de nuevo"); 
			}else {
				return dato;
			}
		}
		
	}
	private int agregarCodigo(Scanner entrada) {
		
		while(true) {
			try {
				System.out.println("Introduce el codigo del estudiante");
				this.codigo=Integer.parseInt(entrada.nextLine());
				
				if(this.codigo<1) {
					System.out.println("El codigo no puede ser menor de 1, introducelo de nuevo");
				}else {
					return this.codigo;
				}
			}catch(NumberFormatException e) {
				System.err.println("Formato de codigo no valido, introducelo de nuevo");
			}
		}
	}
	
	private HashMap<Integer,Double> agregarNotas(Scanner entrada,HashMap<Integer,Double> notas){
		double nota=0.0;
		for(int i=0; i<asignaturas.size();i++) {
			
			while(true) {
				try {
					System.out.println("Introduce la nota del estudiante para la asignatura de " + asignaturas.get(i+1));
					nota=Double.parseDouble(entrada.nextLine());
					if(nota<0 || nota>10) {
						System.out.println("La nota tiene que estar comprendida entre 0 y 10, introducela de nuevo");
					}else {
						notas.put(i+1, nota);
						break;
					}
				}catch(NumberFormatException e) {
					System.err.println("Formato de nota no valido, introducelo d enuevo");
				}
			}
		}
		return notas;
	}
	
	public HashMap<Integer,Estudiante> agregarEstudiante(Scanner entrada,HashMap<Integer,Estudiante> listaEstudiantes){
		asignaturas.put(1, "Matematicas");
		asignaturas.put(2, "Lenguaje");
	    asignaturas.put(3, "Sociales");
	    asignaturas.put(4, "Naturaleza");
	    asignaturas.put(5, "Gymnasia");
	    asignaturas.put(6, "Dibujo");
	    asignaturas.put(7, "Quimica");
	    asignaturas.put(8, "Fisica");
		this.codigo=agregarCodigo(entrada);
		if(listaEstudiantes.containsKey(this.codigo)) {
			System.out.println("El codigo de estudiante ya esta en uso");
		}else {
			this.nombre=campoTexto(entrada,"nombre");
			this.apellido=campoTexto(entrada,"apellido");
			this.notas=agregarNotas(entrada,notas);
			Estudiante estudiante=new Estudiante(this.nombre,this.apellido,this.asignaturas,this.notas);
			
			listaEstudiantes.put(this.codigo, estudiante);
			
			System.out.println("Estudiante agregado correctamente");
		}
		
		
		
		return listaEstudiantes;
	}
	
	public HashMap<Integer, Estudiante> actualizarNota(Scanner entrada, HashMap<Integer, Estudiante> listaEstudiantes) {
	    // Verificar si hay estudiantes en la lista
	    if (listaEstudiantes.isEmpty()) {
	        System.out.println("Aún no hay estudiantes dados de alta.");
	    } else {
	        // Solicitar el código del estudiante
	        this.codigo = agregarCodigo(entrada);
	        
	        // Verificar si el estudiante existe
	        if (!listaEstudiantes.containsKey(this.codigo)) {
	            System.out.println("Ningún estudiante con ese código.");
	        } else {
	            // Solicitar el nombre de la asignatura
	            String asignatura = campoTexto(entrada, "asignatura");
	            
	            // Verificar si la asignatura existe
	            Integer asignaturaKey = null;
	            for (Map.Entry<Integer, String> entry : asignaturas.entrySet()) {
	                if (entry.getValue().equalsIgnoreCase(asignatura)) {
	                    asignaturaKey = entry.getKey();
	                    break;
	                }
	            }
	            
	            if (asignaturaKey == null) {
	                System.out.println("La asignatura no está registrada.");
	            } else {
	                // Solicitar la nueva calificación
	                double nuevaNota = 0.0;
	                while (true) {
	                    try {
	                        System.out.println("Introduce la nueva nota para la asignatura de " + asignatura);
	                        nuevaNota = Double.parseDouble(entrada.nextLine());
	                        
	                        if (nuevaNota < 0 || nuevaNota > 10) {
	                            System.out.println("La nota tiene que estar comprendida entre 0 y 10. Introdúcela de nuevo.");
	                        } else {
	                            break;
	                        }
	                    } catch (NumberFormatException e) {
	                        System.err.println("Formato de nota no válido, introdúcelo de nuevo.");
	                    }
	                }
	                
	                // Actualizar la nota en el mapa de notas del estudiante
	                listaEstudiantes.get(this.codigo).getNotas().put(asignaturaKey, nuevaNota);
	                System.out.println("Nota actualizada correctamente para la asignatura " + asignatura + ".");
	            }
	        }
	    }
	    
	    return listaEstudiantes;
	}
	public void consultarNotas(Scanner entrada,HashMap<Integer,Estudiante> listaEstudiantes) {
		if(listaEstudiantes.isEmpty()) {
			System.out.println("La lista de estudinates esta vacia");
		}else {
			this.codigo=agregarCodigo(entrada);
			
			if(!listaEstudiantes.containsKey(this.codigo)) {
				System.out.println("No hay ningun estudinate con ese codigo");
			}else {
				System.out.println(listaEstudiantes.get(this.codigo).asignaturas);
				System.out.println(listaEstudiantes.get(this.codigo).notas);
			}
		}
	}
	
	public void consultarTodasNotas(Scanner entrada,HashMap<Integer,Estudiante> listaEstudiantes) {
		if(listaEstudiantes.isEmpty()) {
			System.out.println("La lista de estudinates esta vacia");
		}else {

				System.out.println(listaEstudiantes.get(this.codigo).asignaturas);
				System.out.println(listaEstudiantes.get(this.codigo).notas);
			}
		}

	
	public void consultarMediaNotas(Scanner entrada, HashMap<Integer, Estudiante> listaEstudiantes) {
	    // Verificar si la lista de estudiantes está vacía
	    if (listaEstudiantes.isEmpty()) {
	        System.out.println("La lista de estudiantes está vacía.");
	    } else {
	        // Solicitar el código del estudiante
	        this.codigo = agregarCodigo(entrada);
	        
	        // Verificar si el estudiante existe
	        if (!listaEstudiantes.containsKey(this.codigo)) {
	            System.out.println("No hay ningún estudiante con ese código.");
	        } else {
	            // Obtener el estudiante con el código ingresado
	            Estudiante estudiante = listaEstudiantes.get(this.codigo);
	            
	            // Acceder a sus notas
	            HashMap<Integer, Double> notas = estudiante.getNotas();
	            
	            // Calcular la media de las notas
	            double suma = 0.0;
	            for (Double nota : notas.values()) {
	                suma += nota;
	            }
	            
	            // Verificar que haya notas para calcular la media
	            if (!notas.isEmpty()) {
	                double media = suma / notas.size();
	                System.out.println("La media de las notas de " + estudiante.getNombre() + " es: " + media);
	            } else {
	                System.out.println("No hay notas registradas para este estudiante.");
	            }
	        }
	    }
	}

	
	public HashMap<Integer,Estudiante> borrarAsignatura(Scanner entrada,HashMap<Integer,Estudiante> listaEstudiantes){
		if(listaEstudiantes.isEmpty()) {
			System.out.println("La lista de estudinates esta vacia");
		}else {
			this.codigo=agregarCodigo(entrada);
			if(!listaEstudiantes.containsKey(this.codigo)){
				System.out.println("No hay ningun estudiante con ese codigo");
			}else {
				// Solicitar el nombre de la asignatura
	            String asignatura = campoTexto(entrada, "asignatura");
	            
	            // Verificar si la asignatura existe
	            Integer asignaturaKey = null;
	            for (Map.Entry<Integer, String> entry : asignaturas.entrySet()) {
	                if (entry.getValue().equalsIgnoreCase(asignatura)) {
	                    asignaturaKey = entry.getKey();
	                    break;
	                }
	            }
	            
	            if (asignaturaKey == null) {
	                System.out.println("La asignatura no está registrada.");
	            }else {
	            	char respuesta=' ';
	            	
	            	while(true) {
	            		System.out.println("Seguro que quieres borrar la asignatura " + asignatura + " del estudiante (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') {
	            		notas.remove(asignaturaKey);
		            	asignaturas.remove(asignaturaKey);
		            	System.out.println("Asignatura borra con exito");
	            	}else {
	            		System.out.println("Operacion de borrar asignatura abortada");
	            	}
	            	
	            }
			}
		}
		return listaEstudiantes;
	}

}

class MenuEjercicio5{
	HashMap<Integer,Estudiante> listaEstudiantes=new HashMap<Integer,Estudiante>();
	Estudiante estudiante=new Estudiante();
	Scanner entrada =new Scanner(System.in);
	int menu=0;
	
	public void mostrarMenu() {
		do {
			System.out.println("Menu Instituto");
			System.out.println("1.Agregar Estudiante");
			System.out.println("2.Actualizar nota Estudiante");
			System.out.println("3.Borrar asignatura Estudiante");
			System.out.println("4.Consultar nota Estudiante");
			System.out.println("5.Consultar media nota Estudiante");
			System.out.println("6.listar  Estudiante");
			System.out.println("7.Salir");
			System.out.println("Escoge 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 -> listaEstudiantes=estudiante.agregarEstudiante(entrada, listaEstudiantes);
		case 2 -> listaEstudiantes=estudiante.actualizarNota(entrada, listaEstudiantes);
		case 3 -> listaEstudiantes=estudiante.borrarAsignatura(entrada, listaEstudiantes);
		case 4 -> estudiante.consultarNotas(entrada, listaEstudiantes);
		case 5 -> estudiante.consultarMediaNotas(entrada, listaEstudiantes);
		case 6 -> estudiante.consultarTodasNotas(entrada, listaEstudiantes);
		case 7 -> {
			System.out.println("Saliendo el programa ...");
			entrada.close();
			break;
		}
		default -> System.out.println("Opcion no contemplada, introducela de nuevo");
		}
	}
}