Carlos Fernández García

Ejercicio 1

Crea un programa que gestione un sistema de inventario de frutas en una tienda. Utiliza LinkedHashMap para almacenar el nombre de cada fruta (como clave) junto con su cantidad en stock (como valor). El programa debe permitir: Agregar una fruta al inventario con su cantidad. Actualizar la cantidad de una fruta existente. Eliminar una fruta del inventario. Mostrar todas las frutas en el inventario en el orden en que fueron agregadas, junto con sus cantidades.

package linkedhashmap;

import java.util.LinkedHashMap;
import java.util.Scanner;

public class Ejercicio1 {

	public static void main(String[] args) {
		/* Crear y mostrar el menú principal para gestionar el inventario de frutas */
		MenuEjercicio1 menu = new MenuEjercicio1();
		menu.mostrarMenu();
	}
}

class Fruta {
	String nombreFruta;
	double cantidad;
	
	/* Método para solicitar y validar el nombre de la fruta */
	private String agregarNombreFruta(Scanner entrada) {
		while (true) {
			System.out.println("Introduce el nombre de la fruta:");
			this.nombreFruta = entrada.nextLine();
			
			/* Validación para evitar nombres vacíos */
			if (this.nombreFruta.equals("")) {
				System.out.println("El nombre de la fruta no puede quedar en blanco, introdúcelo de nuevo");
			} else {
				return this.nombreFruta;
			}
		}
	}
	
	/* Método para solicitar y validar la cantidad de una fruta */
	private Double agregarCantidad(Scanner entrada, String nombreFruta) {
		while (true) {
			try {
				System.out.println("Introduce la cantidad de " + nombreFruta);
				this.cantidad = Double.parseDouble(entrada.nextLine());
				
				/* Validación para que la cantidad sea positiva */
				if (this.cantidad <= 0) {
					System.out.println("La cantidad de fruta 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 actualizar la cantidad de una fruta en el inventario */
	public LinkedHashMap<String, Double> actualizarFruta(Scanner entrada, LinkedHashMap<String, Double> listaFrutas) {
		if (listaFrutas.isEmpty()) {
			System.out.println("La lista de frutas está vacía aún");
		} else {
			this.nombreFruta = agregarNombreFruta(entrada);
			
			/* Comprobar si la fruta existe antes de actualizar */
			if (!listaFrutas.containsKey(this.nombreFruta)) {
				System.out.println("La fruta no se encuentra en la lista de la frutería");
			} else {
				this.cantidad = agregarCantidad(entrada, this.nombreFruta);
				listaFrutas.put(nombreFruta, this.cantidad);
				System.out.println("Fruta actualizada correctamente");
			}
		}
		return listaFrutas;
	}
	
	/* Método para eliminar una fruta del inventario */
	public LinkedHashMap<String, Double> eliminarFruta(Scanner entrada, LinkedHashMap<String, Double> listaFrutas) {
		if (listaFrutas.isEmpty()) {
			System.out.println("La lista de frutas está vacía aún");
		} else {
			this.nombreFruta = agregarNombreFruta(entrada);
			
			/* Comprobar si la fruta existe antes de eliminar */
			if (!listaFrutas.containsKey(this.nombreFruta)) {
				System.out.println("La fruta no se encuentra en la lista de la frutería");
			} else {
				char respuesta = ' ';
				
				/* Confirmación de borrado por parte del usuario */
				while (true) {
					System.out.println("¿Seguro que quieres borrar la fruta " + this.nombreFruta + " del inventario? (s)(n)");
					respuesta = entrada.nextLine().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;
					}
				}
				
				/* Verificar si el usuario confirmó la eliminación */
				if (respuesta == 'n') {
					System.out.println("Operación de borrado abortada");
				} else {
					listaFrutas.remove(this.nombreFruta);
					System.out.println("Fruta borrada con éxito");
				}
			}
		}
		return listaFrutas;
	}
	
	/* Método para agregar una nueva fruta al inventario */
	public LinkedHashMap<String, Double> agregarFruta(Scanner entrada, LinkedHashMap<String, Double> listaFrutas) {
		this.nombreFruta = agregarNombreFruta(entrada);
		
		/* Verificar si la fruta ya existe antes de agregar */
		if (listaFrutas.containsKey(this.nombreFruta)) {
			System.out.println("La fruta ya estaba dada de alta, no se agregará");
		} else {
			this.cantidad = agregarCantidad(entrada, this.nombreFruta);
			listaFrutas.put(nombreFruta, this.cantidad);
			System.out.println("Fruta agregada correctamente");
		}
		return listaFrutas;
	}
	
	/* Método para mostrar el inventario completo de frutas */
	public void mostrarInventario(LinkedHashMap<String, Double> listaFrutas) {
		if (listaFrutas.isEmpty()) {
			System.out.println("La lista de frutas está vacía aún");
		} else {
			System.out.println("Inventario de la frutería");
			for (String fruta : listaFrutas.keySet()) {
				System.out.println("Fruta: " + fruta + " Stock: " + listaFrutas.get(fruta));
			}
		}
	}
}

class MenuEjercicio1 {
	
	LinkedHashMap<String, Double> listaFrutas = new LinkedHashMap<String, Double>();
	Fruta fruta = new Fruta();
	Scanner entrada = new Scanner(System.in);
	int menu = 0;
	
	/* Método que muestra el menú principal y gestiona las opciones seleccionadas */
	public void mostrarMenu() {
		do {
			System.out.println("Menú Frutería");
			System.out.println("1. Añadir fruta");
			System.out.println("2. Actualizar fruta");
			System.out.println("3. Eliminar fruta");
			System.out.println("4. Listar frutas");
			System.out.println("5. Salir");
			System.out.println("Escoge opción:");
			
			try {
				menu = Integer.parseInt(entrada.nextLine());
				gestionarmenu(menu);
			} catch (NumberFormatException e) {
				System.err.println("Formato de menú incorrecto, introdúcelo de nuevo");
			}
		} while (menu != 5);
	}
	
	/* Método que gestiona las opciones del menú principal */
	private void gestionarmenu(int menu) {
		switch (menu) {
			case 1 -> listaFrutas = fruta.agregarFruta(entrada, listaFrutas);
			case 2 -> listaFrutas = fruta.actualizarFruta(entrada, listaFrutas);
			case 3 -> listaFrutas = fruta.eliminarFruta(entrada, listaFrutas);
			case 4 -> fruta.mostrarInventario(listaFrutas);
			case 5 -> {
				/* Mensaje de salida y cierre del recurso Scanner */
				System.out.println("Saliendo de la frutería ...");
				entrada.close();
				break;
			}
			default -> System.out.println("Opción no contemplada en el menú, introdúcela de nuevo");
		}
	}
}

Ejercicio 2

Desarrolla un programa que gestione un sistema de préstamo de libros en una biblioteca utilizando LinkedHashMap. Cada libro debe estar identificado por su título (clave) y un valor booleano que indique si está disponible (true) o prestado (false). El programa debe permitir: Agregar un nuevo libro a la biblioteca y establecerlo como disponible. Prestar un libro específico, actualizando su estado a "prestado" si está disponible. Si no, muestra un mensaje informando que el libro ya está prestado. Devolver un libro, actualizando su estado a "disponible" si estaba prestado. Mostrar todos los libros de la biblioteca en el orden en que fueron agregados, indicando su estado actual (disponible o prestado).

package linkedhashmap;

import java.util.LinkedHashMap;
import java.util.Scanner;

public class Ejercicio2 {

    public static void main(String[] args) {
        // Se crea una instancia del menú y se muestra el menú
        menuEjercicio2 menu = new menuEjercicio2();
        menu.mostrarMenu();
    }

}

/* Clase Libro que representa los libros de la biblioteca.
 * Cada libro tiene un título (String) y un estado (booleano) que indica si está disponible o prestado.
 */
class Libro {
    String titulo; // Título del libro
    boolean estado; // Estado del libro (true: disponible, false: prestado)
    
    /* Método privado para solicitar al usuario el título del libro. */
    private String campoTitulo(Scanner entrada) {
        while (true) {
            System.out.println("Introduce el titulo del libro:");
            this.titulo = entrada.nextLine(); // Se lee el título del libro
            
            if (this.titulo.equals("")) {
                System.out.println("El titulo no puede quedar en blanco, introdúcelo de nuevo");
            } else {
                return this.titulo; // Devuelve el título si no está vacío
            }
        }
    }
    
    /* Método para prestar un libro. Si el libro está disponible, su estado se cambia a "prestado". */
    public LinkedHashMap<String, Boolean> prestarLibros(Scanner entrada, LinkedHashMap<String, Boolean> listaLibros) {
        if (listaLibros.isEmpty()) {
            System.out.println("Aún no hay libros dados de alta");
        } else {
            this.titulo = campoTitulo(entrada); // Se solicita el título del libro
            
            if (!listaLibros.containsKey(this.titulo)) {
                System.out.println("El título no se encuentra en la biblioteca");
            } else if (listaLibros.containsKey(this.titulo) && !listaLibros.get(this.titulo)) {
                System.out.println("El libro ya se encuentra prestado");
            } else {
                listaLibros.put(this.titulo, false); // Se marca el libro como prestado
                System.out.println("Libro prestado correctamente");
            }
        }
        
        return listaLibros; // Devuelve la lista actualizada de libros
    }
    
    /* Método para devolver un libro. Si el libro estaba prestado, su estado se cambia a "disponible". */
    public LinkedHashMap<String, Boolean> devolverLibros(Scanner entrada, LinkedHashMap<String, Boolean> listaLibros) {
        if (listaLibros.isEmpty()) {
            System.out.println("Aún no hay libros dados de alta");
        } else {
            this.titulo = campoTitulo(entrada); // Se solicita el título del libro
            
            if (!listaLibros.containsKey(this.titulo)) {
                System.out.println("El título no se encuentra en la biblioteca");
            } else if (listaLibros.containsKey(this.titulo) && listaLibros.get(this.titulo)) {
                System.out.println("El libro no se encuentra prestado");
            } else {
                listaLibros.put(this.titulo, true); // Se marca el libro como disponible
                System.out.println("Libro devuelto correctamente");
            }
        }
        
        return listaLibros; // Devuelve la lista actualizada de libros
    }
    
    /* Método para listar todos los libros en la biblioteca con su estado actual (disponible o prestado). */
    public void listarLibros(LinkedHashMap<String, Boolean> listaLibros) {
        if (listaLibros.isEmpty()) {
            System.out.println("Aún no hay libros dados de alta");
        } else {
            System.out.println("Todos los libros de la biblioteca:");
            for (String libro : listaLibros.keySet()) {
                String estado = listaLibros.get(libro) ? "Disponible" : "Prestado"; // Determina el estado del libro
                System.out.println("Libro: " + libro + " Estado: " + estado);
            }
        }
    }
    
    /* Método para listar libros según su estado (disponible o prestado). */
    public void listarLibrosEstado(LinkedHashMap<String, Boolean> listaLibros, boolean estado) {
        if (listaLibros.isEmpty()) {
            System.out.println("Aún no hay libros dados de alta");
        } else {
            if (estado) {
                System.out.println("Todos los libros de la biblioteca sin prestar");
            } else {
                System.out.println("Todos los libros de la biblioteca prestados");
            }
            
            for (String libro : listaLibros.keySet()) {
                if (estado == listaLibros.get(libro)) {
                    System.out.println("Libro: " + libro); // Se muestra el libro según el estado
                }
            }
        }
    }
    
    /* Método para agregar un nuevo libro a la biblioteca. Inicialmente, el libro está disponible. */
    public LinkedHashMap<String, Boolean> agregarLibros(Scanner entrada, LinkedHashMap<String, Boolean> listaLibros) {
        this.titulo = campoTitulo(entrada); // Se solicita el título del libro
        
        if (listaLibros.containsKey(this.titulo)) {
            System.out.println("El título ya se encuentra en la biblioteca");
        } else {
            listaLibros.put(this.titulo, true); // Se agrega el libro como disponible
            System.out.println("Libro agregado correctamente");
        }
        
        return listaLibros; // Devuelve la lista actualizada de libros
    }
}

/* Clase menuEjercicio2 que maneja la interacción con el usuario para elegir opciones en el menú. */
class menuEjercicio2 {
    LinkedHashMap<String, Boolean> listaLibros = new LinkedHashMap<String, Boolean>(); // Lista de libros en la biblioteca
    Libro libro = new Libro(); // Instancia de la clase Libro
    Scanner entrada = new Scanner(System.in); // Scanner para leer la entrada del usuario
    int menu = 0; // Variable para almacenar la opción seleccionada en el menú
    
    /* Método que muestra el menú de opciones y gestiona las selecciones del usuario. */
    public void mostrarMenu() {
        do {
            System.out.println("Biblioteca");
            System.out.println("1. Agregar libro");
            System.out.println("2. Prestar libro");
            System.out.println("3. Devolver libro");
            System.out.println("4. Mostrar libros");
            System.out.println("5. Mostrar libros disponibles");
            System.out.println("6. Mostrar libros prestados");
            System.out.println("7. Salir");
            System.out.println("Escoge opción:");
            
            try {
                menu = Integer.parseInt(entrada.nextLine()); // Se lee la opción del usuario
                gestionarMenu(menu); // Se gestiona la opción seleccionada
            } catch (NumberFormatException e) {
                System.err.println("Formato de menú no válido, introdúcelo de nuevo");
            }
        } while (menu != 7); // El ciclo continúa hasta que el usuario seleccione la opción 7 (Salir)
    }
    
    /* Método que gestiona la acción según la opción seleccionada en el menú. */
    private void gestionarMenu(int menu) {
        switch (menu) {
            case 1 -> listaLibros = libro.agregarLibros(entrada, listaLibros);
            case 2 -> listaLibros = libro.prestarLibros(entrada, listaLibros);
            case 3 -> listaLibros = libro.devolverLibros(entrada, listaLibros);
            case 4 -> libro.listarLibros(listaLibros);
            case 5 -> libro.listarLibrosEstado(listaLibros, true);
            case 6 -> libro.listarLibrosEstado(listaLibros, false);
            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 3

Desarrolla un programa que gestione un registro de inventario de productos electrónicos utilizando LinkedHashMap. Cada producto debe estar identificado por su nombre (clave) y un valor que incluya el precio, la cantidad disponible y una etiqueta de categoría (por ejemplo, "móvil", "ordenador", "accesorio"). El programa debe permitir: Agregar un nuevo producto al inventario, especificando su nombre, precio, cantidad y categoría. Actualizar la cantidad de un producto específico, añadiendo o restando unidades según se reciban nuevas existencias o se realicen ventas. Actualizar el precio de un producto específico, ajustando su valor en el inventario. Eliminar un producto del inventario cuando su cantidad disponible llegue a cero. Listar todos los productos mostrando su nombre, precio, cantidad y categoría, en el orden en que fueron añadidos. Filtrar productos por categoría y mostrar los productos que pertenecen a una categoría específica. Mostrar el producto con el precio más alto y el más bajo de todo el inventario.

package linkedhashmap;

import java.util.LinkedHashMap;
import java.util.Scanner;

public class Ejercicio3 {

    // Método principal del programa
    public static void main(String[] args) {
        // Crear una instancia del menú para que el programa pueda interactuar con el usuario
        MenuEjercicio3 menu = new MenuEjercicio3();
        
        // Mostrar el menú al usuario, lo que iniciará el ciclo de interacción
        menu.mostrarMenu();
    }
}


class Producto {
    // Atributos de la clase Producto
    double precio;  // Precio del producto
    int cantidad;   // Cantidad del producto disponible en inventario
    String categoria; // Categoría del producto

    // Constructor vacío de la clase Producto
    public Producto() {

    }

    // Constructor con parámetros para inicializar el producto con valores dados
    public Producto(double precio, int cantidad, String categoria) {
        this.precio = precio;
        this.cantidad = cantidad;
        this.categoria = categoria;
    }

    // Métodos getter y setter para cada uno de los atributos

    public double getPrecio() {
        return precio;
    }

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

    public int getCantidad() {
        return cantidad;
    }

    public void setCantidad(int cantidad) {
        this.cantidad = cantidad;
    }

    public String getCategoria() {
        return categoria;
    }

    public void setCategoria(String categoria) {
        this.categoria = categoria;
    }

    // Método toString que devuelve la representación en cadena del producto
    @Override
    public String toString() {
        return "\nP.V.P=" + precio + "€\nCantidad=" + cantidad + "\nCategoria=" + categoria;
    }

    // Método para agregar el precio de un producto validando la entrada del usuario
    private double agregarPrecio(Scanner entrada) {
        while (true) {
            try {
                System.out.println("Introduce el P.V.P del producto:");
                this.precio = Double.parseDouble(entrada.nextLine());

                // Validación del precio: debe ser mayor que 0
                if (this.precio <= 0) {
                    System.err.println("El P.V.P no puede ser menor de 1 céntimo, introdúcelo de nuevo");
                } else {
                    return this.precio;
                }
            } catch (NumberFormatException e) {
                System.err.println("Formato de precio inválido, introdúcelo de nuevo");
            }
        }
    }

    // Método para agregar la cantidad del producto, validando la entrada
    private int agregarCantidad(Scanner entrada) {
        while (true) {
            try {
                System.out.println("Introduce la cantidad del producto:");
                this.cantidad = Integer.parseInt(entrada.nextLine());

                // Validación de la cantidad: debe ser al menos 1
                if (this.cantidad < 1) {
                    System.err.println("La cantidad no puede ser menor de 1, introdúcelo de nuevo");
                } else {
                    return this.cantidad;
                }
            } catch (NumberFormatException e) {
                System.err.println("Formato de cantidad inválido, introdúcelo de nuevo");
            }
        }
    }

    // Método para agregar un campo de texto (como el nombre o categoría) y validarlo
    private String campoTexto(Scanner entrada, String campo) {
        String dato = "";

        while (true) {
            System.out.println("Introduce el " + campo + " del producto");
            dato = entrada.nextLine();

            // Validación: el campo no puede estar vacío
            if (dato.equals("")) {
                System.out.println("El campo " + campo + " no puede quedar vacío, introdúcelo de nuevo");
            } else {
                return dato;
            }
        }
    }

    // Método para actualizar el precio de un producto en el inventario
    public LinkedHashMap<String, Producto> actualizarPrecioProducto(Scanner entrada, LinkedHashMap<String, Producto> inventario) {
        if (inventario.isEmpty()) {
            System.out.println("El inventario aún está vacío");
        } else {
            String nombreProducto = campoTexto(entrada, "nombre");

            if (!inventario.containsKey(nombreProducto)) {
                System.out.println("El producto no se encuentra en el inventario");
            } else {
                System.out.println("Introduce el nuevo P.V.P del producto");
                double precioProducto = agregarPrecio(entrada);

                // Actualizar el precio del producto en el inventario
                inventario.get(nombreProducto).setPrecio(precioProducto);
                System.out.println("P.V.P del producto actualizado correctamente");
            }
        }

        return inventario;
    }

    // Método para actualizar la cantidad de un producto en el inventario
    public LinkedHashMap<String, Producto> actualizarCantidadProducto(Scanner entrada, LinkedHashMap<String, Producto> inventario) {
        if (inventario.isEmpty()) {
            System.out.println("El inventario aún está vacío");
        } else {
            boolean balance = false;

            char respuestaVenta = ' ';
            while (true) {
                System.out.println("¿Quieres hacer una (v)enta o una (a)ctualización de Stock?");
                respuestaVenta = entrada.nextLine().toLowerCase().charAt(0);

                // Validación de la respuesta
                if (respuestaVenta != 'v' && respuestaVenta != 'a') {
                    System.out.println("La respuesta tiene que ser venta (v) o actualización (a), introdúcela de nuevo");
                } else {
                    break;
                }
            }

            balance = respuestaVenta == 'v';

            String nombreProducto = campoTexto(entrada, "nombre");

            if (!inventario.containsKey(nombreProducto)) {
                System.out.println("El producto no se encuentra en el inventario");
            } else {
                int cantidad = agregarCantidad(entrada);

                // Actualización de la cantidad según el tipo de acción (venta o actualización)
                if (!balance) {
                    // Actualización de stock
                    inventario.get(nombreProducto).setCantidad(inventario.get(nombreProducto).getCantidad() + cantidad);
                    System.out.println("Stock del producto actualizado correctamente");
                } else {
                    // Venta del producto
                    if (cantidad > inventario.get(nombreProducto).getCantidad()) {
                        System.out.println("Stock insuficiente, abortada venta");
                    } else {
                        inventario.get(nombreProducto).setCantidad(inventario.get(nombreProducto).getCantidad() - cantidad);
                        System.out.println("Venta realizada con éxito");

                        // Si la cantidad llega a 0, se elimina el producto del inventario
                        if (inventario.get(nombreProducto).getCantidad() == 0) {
                            inventario.remove(nombreProducto);
                            System.out.println("El producto se ha quedado sin stock y se ha borrado del inventario.");
                        }
                    }
                }
            }
        }

        return inventario;
    }

    // Método para agregar un nuevo producto al inventario
    public LinkedHashMap<String, Producto> agregarProducto(Scanner entrada, LinkedHashMap<String, Producto> inventario) {
        String nombreProducto = campoTexto(entrada, "nombre");

        if (inventario.containsKey(nombreProducto)) {
            System.out.println("El producto ya está dado de alta en el inventario, no se agregará");
        } else {
            Producto producto = new Producto();

            // Agregar precio, cantidad y categoría del producto
            producto.setPrecio(agregarPrecio(entrada));
            producto.setCantidad(agregarCantidad(entrada));
            producto.setCategoria(campoTexto(entrada, "categoria"));

            // Añadir el producto al inventario
            inventario.put(nombreProducto, producto);
            System.out.println("Producto agregado con éxito al inventario");
        }

        return inventario;
    }

    // Método para listar todos los productos del inventario
    public void listarInventario(LinkedHashMap<String, Producto> inventario) {
        if (inventario.isEmpty()) {
            System.out.println("El inventario aún está vacío");
        } else {
            System.out.println("Listado del inventario");
            int contadorProductos = 0;
            for (String nombreProducto : inventario.keySet()) {
                System.out.println("Producto: " + nombreProducto + inventario.get(nombreProducto).toString());
                contadorProductos++;
            }

            System.out.println("Hay un total de " + contadorProductos + " productos dados de alta en el inventario");
        }
    }

    // Método para mostrar el producto más caro y el más barato en el inventario
    public void productosTop(LinkedHashMap<String, Producto> inventario) {
        if (inventario.isEmpty()) {
            System.out.println("El inventario aún está vacío");
        } else {
            double precioCaro = Double.MIN_VALUE;
            double precioBarato = Double.MAX_VALUE;
            Producto productoCaro = new Producto();
            Producto productoBarato = new Producto();
            String caro = "";
            String barato = "";

            // Buscar el producto más caro y el más barato
            for (String nombreProducto : inventario.keySet()) {
                if (inventario.get(nombreProducto).getPrecio() > precioCaro) {
                    precioCaro = inventario.get(nombreProducto).getPrecio();
                    productoCaro = inventario.get(nombreProducto);
                    caro = nombreProducto;
                }

                if (inventario.get(nombreProducto).getPrecio() < precioBarato) {
                    precioBarato = inventario.get(nombreProducto).getPrecio();
                    productoBarato = inventario.get(nombreProducto);
                    barato = nombreProducto;
                }
            }

            // Mostrar los resultados
            System.out.println("Datos del producto más caro");
            System.out.println("Producto: " + caro + productoCaro.toString());

            System.out.println("Datos del producto más barato");
            System.out.println("Producto: " + barato + productoBarato.toString());
        }
    }
	
 // Método para listar productos de una categoría específica en el inventario
    public void listarInventarioCategoria(Scanner entrada, LinkedHashMap<String, Producto> inventario) {
        // Verifica si el inventario está vacío
        if (inventario.isEmpty()) {
            System.out.println("El inventario aún está vacío");
        } else {
            // Solicita al usuario la categoría de los productos que desea listar
            String categoria = campoTexto(entrada, "categoria");

            // Variable para verificar si existe al menos un producto en la categoría especificada
            boolean existeCategoria = false;

            // Recorre el inventario para comprobar si existe algún producto de la categoría solicitada
            for (String nombreProducto : inventario.keySet()) {
                if (inventario.get(nombreProducto).getCategoria().equalsIgnoreCase(categoria)) {
                    existeCategoria = true; // Si encuentra al menos uno, cambia el valor a true
                }
            }

            // Si no existe ningún producto en la categoría solicitada, se informa al usuario
            if (!existeCategoria) {
                System.out.println("Ningún producto de esa categoría");
            } else {
                // Si existe al menos un producto, muestra un mensaje de inicio de listado
                System.out.println("Listado del inventario de la categoría " + categoria);
                int contadorProductos = 0;

                // Recorre nuevamente el inventario para listar solo los productos de la categoría especificada
                for (String nombreProducto : inventario.keySet()) {
                    if (inventario.get(nombreProducto).getCategoria().equalsIgnoreCase(categoria)) {
                        // Muestra la información de cada producto de la categoría
                        System.out.println("Producto: " + nombreProducto + inventario.get(nombreProducto).toString());
                        contadorProductos++; // Incrementa el contador de productos listados
                    }
                }

                // Muestra el número total de productos encontrados en la categoría solicitada
                System.out.println("Hay un total de " + contadorProductos + " productos dados de alta en el inventario de la categoría " + categoria);
            }
        }
    }

}

class MenuEjercicio3 {
    // Mapa que almacena productos, clave es el nombre del producto, valor es un objeto Producto
    LinkedHashMap<String, Producto> inventario = new LinkedHashMap<String, Producto>();
    // Instancia de Producto para manejar las operaciones de los productos
    Producto producto = new Producto();
    // Escáner para la entrada de datos del usuario
    Scanner entrada = new Scanner(System.in);
    // Variable para almacenar la opción seleccionada en el menú
    int menu = 0;

    // Método para mostrar el menú e interactuar con el usuario
    public void mostrarMenu() {
        // Ciclo do-while que muestra el menú y ejecuta las opciones hasta que el usuario elija salir
        do {
            System.out.println("MENU INVENTARIO");
            System.out.println("1. Agregar producto");
            System.out.println("2. Actualizar la cantidad de producto");
            System.out.println("3. Actualizar el precio producto");
            System.out.println("4. Listar todos los productos");
            System.out.println("5. Filtrar producto por categoria");
            System.out.println("6. Mostrar producto más barato y más caro");
            System.out.println("7. Salir del programa");
            System.out.println("Escoge opción:");

            try {
                // Lee la opción ingresada por el usuario
                menu = Integer.parseInt(entrada.nextLine());
                // Llama al método gestionarMenu para procesar la opción seleccionada
                gestionarMenu(menu);
            } catch (NumberFormatException e) {
                // Maneja la excepción en caso de que el usuario ingrese un valor no numérico
                System.err.println("Formato de menú no válido, introdúcelo de nuevo");
            }
        } while (menu != 7); // El ciclo continúa hasta que el usuario elige salir (opción 7)
    }

    // Método para gestionar las opciones del menú
    private void gestionarMenu(int menu) {
        // Estructura switch para manejar las distintas opciones del menú
        switch (menu) {
            case 1 -> inventario = producto.agregarProducto(entrada, inventario); // Agrega un producto
            case 2 -> inventario = producto.actualizarCantidadProducto(entrada, inventario); // Actualiza la cantidad de un producto
            case 3 -> inventario = producto.actualizarPrecioProducto(entrada, inventario); // Actualiza el precio de un producto
            case 4 -> producto.listarInventario(inventario); // Lista todos los productos del inventario
            case 5 -> producto.listarInventarioCategoria(entrada, inventario); // Filtra y lista productos por categoría
            case 6 -> producto.productosTop(inventario); // Muestra los productos más baratos y más caros
            case 7 -> {
                System.out.println("Saliendo del programa ..."); // Mensaje de salida
                entrada.close(); // Cierra el escáner para liberar recursos
                break; // Sale del ciclo y termina el programa
            }
            default -> System.out.println("Opción no contemplada en el menú, introdúcela de nuevo"); // Mensaje si la opción es inválida
        }
    }
}

Ejercicio 4

Crea un programa en Java que gestione un catálogo de empleados en una empresa. El programa debe utilizar un LinkedHashMap para almacenar los empleados, donde la clave es el número de identificación del empleado (un valor único) y el valor es un objeto Empleado que contiene los siguientes atributos: nombre: Nombre completo del empleado. departamento: Departamento en el que trabaja. salario: Salario mensual del empleado. El programa debe permitir las siguientes operaciones: Agregar un nuevo empleado al catálogo (con su identificación, nombre, departamento y salario). Actualizar la información de un empleado: Cambiar el salario o el departamento de un empleado dado su número de identificación. Eliminar un empleado del catálogo utilizando su número de identificación. Listar todos los empleados mostrando su nombre, departamento y salario. Buscar empleados por departamento: Mostrar todos los empleados que trabajan en un departamento específico. Calcular el salario promedio de todos los empleados en el catálogo.

package linkedhashmap; // Paquete que contiene las clases y archivos relacionados con LinkedHashMap

import java.util.LinkedHashMap; // Importación de la clase LinkedHashMap
import java.util.Scanner; // Importación de la clase Scanner para la entrada de datos por el usuario

public class Ejercicio4 {

    // Método principal del programa, donde se inicia la ejecución
    public static void main(String[] args) {
        
        // Creación de una instancia de la clase MenuEjercicio4
        // para gestionar y mostrar el menú de opciones al usuario
        MenuEjercicio4 menu = new MenuEjercicio4();
        
        // Llamada al método mostrarMenu() para desplegar el menú de opciones
        menu.mostrarMenu();
        
    }

}


class Empleado {
    // Atributos del empleado
    int codigoEmpleado; // Código único del empleado
    String nombre; // Nombre del empleado
    String departamento; // Departamento donde trabaja el empleado
    double salario; // Salario del empleado

    // Constructor sin parámetros
    public Empleado() {
    }

    // Constructor con parámetros para inicializar los atributos principales
    public Empleado(String nombre, String departamento, double salario) {
        this.nombre = nombre;
        this.departamento = departamento;
        this.salario = salario;
    }

    // Métodos getter y setter para cada atributo
    public String getNombre() {
        return nombre;
    }

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

    public String getDepartamento() {
        return departamento;
    }

    public void setDepartamento(String departamento) {
        this.departamento = departamento;
    }

    public double getSalario() {
        return salario;
    }

    public void setSalario(double salario) {
        this.salario = salario;
    }

    public int getCodigoEmpleado() {
        return codigoEmpleado;
    }

    // Método toString que muestra los datos del empleado en formato legible
    @Override
    public String toString() {
        return "\nNombre=" + nombre + "\nDepartamento=" + departamento + "\nSalario=" + salario + "€";
    }

    // Método para pedir datos de tipo texto al usuario con validación
    private String campoTexto(Scanner entrada, String campo) {
        String dato = "";
        while (true) {
            System.out.println("Introduce el " + campo + " del empleado:");
            dato = entrada.nextLine();
            
            // Validación para asegurarse de que el campo no esté vacío
            if (dato.equals("")) {
                System.out.println("El campo " + campo + " no puede quedar vacío, introdúcelo de nuevo");
            } else {
                return dato; // Retorna el dato cuando es válido
            }
        }
    }

    // Método para ingresar y validar el salario del empleado
    private double agregarSalario(Scanner entrada) {
        while (true) {
            try {
                System.out.println("Introduce el salario del empleado:");
                this.salario = Double.parseDouble(entrada.nextLine());

                // Verifica que el salario sea igual o mayor que el salario mínimo interprofesional (SMI)
                if (this.salario < 1323) {
                    System.out.println("El SMI en España con 12 pagas es de 1323, introduce un salario igual o mayor a este");
                } else {
                    return this.salario; // Retorna el salario válido
                }
            } catch (NumberFormatException e) {
                System.err.println("Formato de salario no válido, introdúcelo de nuevo");
            }
        }
    }

    // Método para ingresar y validar el código del empleado
    private int agregarCodigo(Scanner entrada) {
        while (true) {
            try {
                System.out.println("Introduce el código del empleado:");
                this.codigoEmpleado = Integer.parseInt(entrada.nextLine());

                // Verifica que el código de empleado sea positivo
                if (this.codigoEmpleado < 1) {
                    System.out.println("El código de empleado no puede ser menor que 1, introdúcelo de nuevo");
                } else {
                    return this.codigoEmpleado; // Retorna el código válido
                }
            } catch (NumberFormatException e) {
                System.err.println("Formato de código de empleado no válido, introdúcelo de nuevo");
            }
        }
    }

    // Método para actualizar el salario de un empleado en la lista de empleados
    private LinkedHashMap<Integer, Empleado> actualizarSalario(Scanner entrada, LinkedHashMap<Integer, Empleado> listaEmpleados, int codigo) {
        this.salario = agregarSalario(entrada); // Pide el nuevo salario y lo asigna

        // Actualiza el salario en el LinkedHashMap con el código proporcionado
        listaEmpleados.get(codigo).setSalario(this.salario);

        System.out.println("Salario del empleado " + listaEmpleados.get(codigo).getNombre() + " actualizado con éxito a " + this.salario + "€");

        return listaEmpleados; // Retorna la lista actualizada
    }

    // Método para actualizar el departamento de un empleado en la lista de empleados
    private LinkedHashMap<Integer, Empleado> actualizarDepartamento(Scanner entrada, LinkedHashMap<Integer, Empleado> listaEmpleados, int codigo) {
        this.departamento = campoTexto(entrada, "departamento"); // Pide el nuevo departamento y lo asigna

        // Actualiza el departamento en el LinkedHashMap con el código proporcionado
        listaEmpleados.get(codigo).setDepartamento(this.departamento);

        System.out.println("Departamento del empleado " + listaEmpleados.get(codigo).getNombre() + " actualizado con éxito a " + this.departamento);

        return listaEmpleados; // Retorna la lista actualizada
    }

    // Método para eliminar un empleado de la lista
    public LinkedHashMap<Integer, Empleado> eliminarEmpleado(Scanner entrada, LinkedHashMap<Integer, Empleado> listaEmpleados) {
        if (listaEmpleados.isEmpty()) {
            System.out.println("Aún no hay empleados dados de alta en la empresa");
        } else {
            this.codigoEmpleado = agregarCodigo(entrada); // Pide el código del empleado a eliminar

            // Verifica si el empleado con ese código existe en la lista
            if (!listaEmpleados.containsKey(this.codigoEmpleado)) {
                System.out.println("No hay ningún empleado con ese código en la empresa");
            } else {
                char respuesta = ' ';

                // Confirma la eliminación del empleado con una respuesta del usuario
                while (true) {
                    System.out.println("¿Seguro que quieres borrar al empleado " + listaEmpleados.get(this.codigoEmpleado).getNombre() + " (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;
                    }
                }
                
                // Si la respuesta es afirmativa, elimina al empleado
                if (respuesta == 's') {
                    listaEmpleados.remove(this.codigoEmpleado);
                    System.out.println("Empleado despedido con éxito");
                } else {
                    System.out.println("Operación de borrado de empleado abortada");
                }
            }
        }
        return listaEmpleados; // Retorna la lista actualizada
    }


	
 // Método para listar todos los empleados en la empresa
    public void listarEmpleados(LinkedHashMap<Integer, Empleado> listaEmpleados) {
        // Verifica si la lista está vacía
        if (listaEmpleados.isEmpty()) {
            System.out.println("Aun no hay empleados dados de alta en la empresa");
        } else {
            int cuentoEmpleados = 0;
            System.out.println("Listado de empleados en la empresa");

            // Recorre cada empleado en la lista e imprime sus datos
            for (Integer codigo : listaEmpleados.keySet()) {
                System.out.println("\nCodigo:" + codigo + listaEmpleados.get(codigo).toString());
                cuentoEmpleados++;
            }

            // Imprime el total de empleados listados
            System.out.println("Hay un total de " + cuentoEmpleados + " empleados en la empresa");
        }
    }

    // Método para calcular y mostrar el salario medio de los empleados
    public void calcularSalarioMedio(LinkedHashMap<Integer, Empleado> listaEmpleados) {
        // Verifica si la lista está vacía
        if (listaEmpleados.isEmpty()) {
            System.out.println("Aun no hay empleados dados de alta en la empresa");
        } else {
            double salarioMedio = 0.0;

            // Suma el salario de cada empleado
            for (Integer codigo : listaEmpleados.keySet()) {
                salarioMedio += listaEmpleados.get(codigo).getSalario();
            }

            // Calcula el salario medio dividiendo por el número de empleados
            salarioMedio = salarioMedio / listaEmpleados.size();

            // Muestra el salario medio redondeado a dos decimales
            System.out.println("El salario medio de los empleados es: " + String.format("%.2f", salarioMedio) + "€");
        }
    }

    // Método para listar empleados de un departamento específico
    public void listarEmpleadosDepartamentos(Scanner entrada, LinkedHashMap<Integer, Empleado> listaEmpleados) {
        // Verifica si la lista está vacía
        if (listaEmpleados.isEmpty()) {
            System.out.println("Aun no hay empleados dados de alta en la empresa");
        } else {
            this.departamento = campoTexto(entrada, "departamento"); // Pide el departamento

            boolean existeDepartamento = false;

            // Verifica si hay empleados en el departamento especificado
            for (Integer codigo : listaEmpleados.keySet()) {
                if (listaEmpleados.get(codigo).getDepartamento().equalsIgnoreCase(departamento)) {
                    existeDepartamento = true;
                    break;
                }
            }
            if (!existeDepartamento) {
                System.out.println("El departamento no existe en nuestra empresa");
            } else {
                int cuentoEmpleados = 0;
                System.out.println("Listado de empleados del departamento " + departamento + " en la empresa");

                // Lista los empleados del departamento encontrado
                for (Integer codigo : listaEmpleados.keySet()) {
                    Empleado empleado = listaEmpleados.get(codigo);
                    if (empleado.getDepartamento().equalsIgnoreCase(departamento)) {
                        System.out.println("\nCodigo:" + codigo + empleado.toString());
                        cuentoEmpleados++;
                    }
                }

                // Muestra el total de empleados en el departamento
                System.out.println("En el departamento " + departamento + " hay un total de " + cuentoEmpleados + " empleados");
            }
        }
    }

    // Método para actualizar datos de un empleado específico
    public LinkedHashMap<Integer, Empleado> actualizarEmpleado(Scanner entrada, LinkedHashMap<Integer, Empleado> listaEmpleados) {
        // Verifica si la lista está vacía
        if (listaEmpleados.isEmpty()) {
            System.out.println("Aun no hay empleados dados de alta en la empresa");
        } else {
            this.codigoEmpleado = agregarCodigo(entrada); // Pide el código del empleado a actualizar

            // Verifica si el empleado con el código ingresado existe
            if (!listaEmpleados.containsKey(this.codigoEmpleado)) {
                System.out.println("No hay ningun empleado con ese codigo en la empresa");
            } else {
                int menuActualizo = 0;

                // Muestra el menú de opciones para actualizar
                do {
                    System.out.println("Opcion de actualizacion");
                    System.out.println("1. Actualizar salario");
                    System.out.println("2. Actualizar departamento");
                    System.out.println("Escoge opcion");

                    // Captura y valida la opción ingresada
                    try {
                        menuActualizo = Integer.parseInt(entrada.nextLine());
                    } catch (NumberFormatException e) {
                        System.err.println("Formato de menu no valido, introducelo de nuevo");
                    }

                } while (menuActualizo < 1 || menuActualizo > 2);

                // Actualiza el salario o el departamento del empleado según la opción elegida
                switch (menuActualizo) {
                    case 1 -> listaEmpleados = actualizarSalario(entrada, listaEmpleados, codigoEmpleado);
                    case 2 -> listaEmpleados = actualizarDepartamento(entrada, listaEmpleados, codigoEmpleado);
                }
            }
        }

        return listaEmpleados; // Retorna la lista de empleados actualizada
    }

    // Método para agregar un nuevo empleado a la lista
    public LinkedHashMap<Integer, Empleado> agregarEmpleado(Scanner entrada, LinkedHashMap<Integer, Empleado> listaEmpleados) {
        this.codigoEmpleado = agregarCodigo(entrada); // Pide el código único del empleado

        // Verifica si el código de empleado ya está en uso
        if (listaEmpleados.containsKey(this.codigoEmpleado)) {
            System.out.println("El codigo de empleado ya esta en uso");

        } else {
            // Crea un nuevo empleado con los datos ingresados y lo agrega a la lista
            Empleado empleado = new Empleado(
                    campoTexto(entrada, "nombre"),
                    campoTexto(entrada, "departamento"),
                    agregarSalario(entrada)
            );
            listaEmpleados.put(this.codigoEmpleado, empleado);
            System.out.println("Empleado agregado con exito");
        }
        return listaEmpleados; // Retorna la lista de empleados actualizada
    }

}

//Clase que representa el menú principal para gestionar empleados
class MenuEjercicio4 {
 // Mapa para almacenar empleados, donde la clave es un código único y el valor es el objeto Empleado
 LinkedHashMap<Integer, Empleado> listaEmpleados = new LinkedHashMap<Integer, Empleado>();
 // Instancia de Empleado para acceder a los métodos de gestión de empleados
 Empleado empleado = new Empleado();
 // Scanner para capturar la entrada del usuario
 Scanner entrada = new Scanner(System.in);
 int menu = 0; // Variable para almacenar la opción seleccionada en el menú

 // Método para mostrar y gestionar el menú principal de empleados
 public void mostrarMenu() {
     do {
         // Muestra las opciones del menú
         System.out.println("Menu Empleados");
         System.out.println("1. Agregar empleado");
         System.out.println("2. Actualizar empleado");
         System.out.println("3. Eliminar empleado");
         System.out.println("4. Listar todos los empleados");
         System.out.println("5. Buscar empleados por departamento");
         System.out.println("6. Calcular salario promedio");
         System.out.println("7. Salir");
         System.out.println("Escoge opcion:");

         try {
             // Intenta capturar y convertir la entrada del usuario a entero
             menu = Integer.parseInt(entrada.nextLine());
             // Llama al método para gestionar la opción seleccionada
             gestionarMenu(menu);
         } catch (NumberFormatException e) {
             // Muestra un mensaje de error si la entrada no es un número válido
             System.err.println("Formato de menu no valido, introducelo de nuevo");
         }
     } while (menu != 7); // El menú se repite hasta que el usuario elija la opción 7 (Salir)
 }

 // Método para ejecutar la acción correspondiente a la opción seleccionada en el menú
 private void gestionarMenu(int menu) {
     switch (menu) {
         case 1 -> // Llama al método para agregar un empleado
             listaEmpleados = empleado.agregarEmpleado(entrada, listaEmpleados);
         case 2 -> // Llama al método para actualizar un empleado
             listaEmpleados = empleado.actualizarEmpleado(entrada, listaEmpleados);
         case 3 -> // Llama al método para eliminar un empleado
             listaEmpleados = empleado.eliminarEmpleado(entrada, listaEmpleados);
         case 4 -> // Llama al método para listar todos los empleados
             empleado.listarEmpleados(listaEmpleados);
         case 5 -> // Llama al método para buscar empleados por departamento
             empleado.listarEmpleadosDepartamentos(entrada, listaEmpleados);
         case 6 -> // Llama al método para calcular el salario promedio de los empleados
             empleado.calcularSalarioMedio(listaEmpleados);
         case 7 -> {
             // Mensaje de despedida y cierre del Scanner
             System.out.println("Saliendo del programa de empleados");
             entrada.close();
             break; // Termina la ejecución del menú
         }
         default -> // Mensaje para opciones no válidas en el menú
             System.out.println("Opcion no contemplada en el menu, introducela de nuevo");
     }
 }
}

Ejercicio 5

Diseña una aplicación en Java que permita gestionar el inventario de herramientas de un taller. El programa debe ofrecer un menú con las siguientes opciones: Agregar herramienta: Permitir al usuario ingresar información sobre una nueva herramienta (nombre, categoría, cantidad en stock, y costo). El código de cada herramienta debe ser único. Actualizar stock: Permitir al usuario ingresar el código de una herramienta y actualizar su cantidad en stock. Eliminar herramienta: Permitir al usuario ingresar el código de una herramienta y eliminarla del inventario, previo aviso de confirmación. Listar herramientas: Mostrar un listado con todas las herramientas registradas en el inventario, incluyendo su código, nombre, categoría, cantidad en stock y costo. Salir: Finalizar el programa.

package linkedhashmap;

import java.util.LinkedHashMap;
import java.util.Scanner;

public class Ejercicio5 {

	public static void main(String[] args) {
		
		// Creación de una instancia de la clase MenuEjercicio5
        // para gestionar y mostrar el menú de opciones al usuario
        MenuEjercicio5 menu = new MenuEjercicio5();
        
        // Llamada al método mostrarMenu() para desplegar el menú de opciones
        menu.mostrarMenu();

	}

}

class Herramienta{
	int codigo;
	String nombre;
	String categoria;
	int cantidad;
	double costo;
	
	public Herramienta() {
		
	}

	public Herramienta(String nombre, String categoria, int cantidad, double costo) {
		this.nombre = nombre;
		this.categoria = categoria;
		this.cantidad = cantidad;
		this.costo = costo;
	}

	public String getNombre() {
		return nombre;
	}

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

	public String getCategoria() {
		return categoria;
	}

	public void setCategoria(String categoria) {
		this.categoria = categoria;
	}

	public int getCantidad() {
		return cantidad;
	}

	public void setCantidad(int cantidad) {
		this.cantidad = cantidad;
	}

	public double getCosto() {
		return costo;
	}

	public void setCosto(double costo) {
		this.costo = costo;
	}

	public int getCodigo() {
		return codigo;
	}

	@Override
	public String toString() {
		return "\nNombre=" + nombre + "\ncategoria=" + categoria + "\ncantidad=" + cantidad + "\ncosto="
				+ costo + "€";
	}
	
	
    
    // Método para ingresar y validar el código de la herramienta
    private int agregarInt(Scanner entrada,String campo) {
    	int dato=0;
        while (true) {
            try {
                System.out.println("Introduce el " + campo + " de la herramienta:");
                dato = Integer.parseInt(entrada.nextLine());

                // Verifica que el código de la herramienta sea positivo
                if (dato < 1) {
                    System.out.println("El " + campo + " de la herramienta no puede ser menor que 1, introdúcelo de nuevo");
                } else {
                    return dato; // Retorna el código válido
                }
            } catch (NumberFormatException e) {
                System.err.println("Formato de " + campo + " de herramienta no válido, introdúcelo de nuevo");
            }
        }
    }
	
	// Método para pedir datos de tipo texto al usuario con validación
    private String campoTexto(Scanner entrada, String campo) {
        String dato = "";
        while (true) {
            System.out.println("Introduce el " + campo + " de la herramienta:");
            dato = entrada.nextLine();
            
            // Validación para asegurarse de que el campo no esté vacío
            if (dato.equals("")) {
                System.out.println("El campo " + campo + " no puede quedar vacío, introdúcelo de nuevo");
            } else {
                return dato; // Retorna el dato cuando es válido
            }
        }
    }
    
 // Método para ingresar y validar el costo de la herramienta
    private double agregarCosto(Scanner entrada) {
        while (true) {
            try {
                System.out.println("Introduce el precio de la herramienta:");
                this.costo = Double.parseDouble(entrada.nextLine());

                // Verifica que el salario sea igual o mayor que el salario mínimo interprofesional (SMI)
                if (this.costo < 0.01) {
                    System.out.println("El preciode la herramienta no puede ser inferior a 1 centimo de €, introducelo de nuevo");
                } else {
                    return this.costo; // Retorna el salario válido
                }
            } catch (NumberFormatException e) {
                System.err.println("Formato de salario no válido, introdúcelo de nuevo");
            }
        }
    }
	
	public LinkedHashMap<Integer, Herramienta> agregarHerramienta(Scanner entrada, LinkedHashMap<Integer, Herramienta> inventarioTaller) {
        this.codigo = agregarInt(entrada,"codigo"); // Pide el código único del empleado

        // Verifica si el código de empleado ya está en uso
        if (inventarioTaller.containsKey(this.codigo)) {
            System.out.println("El codigo de herramieta ya esta en uso");

        } else {
            // Crea un nuevo empleado con los datos ingresados y lo agrega a la lista
            Herramienta herramienta = new Herramienta(
                    campoTexto(entrada, "nombre"),
                    campoTexto(entrada, "categoria"),
                    agregarInt(entrada,"stock"),
                    agregarCosto(entrada)
            );
            inventarioTaller.put(this.codigo, herramienta);
            System.out.println("Empleado agregado con exito");
        }
        return inventarioTaller; // Retorna la lista de empleados actualizada
    }
	
	// Método para actualizar el departamento de un empleado en la lista de empleados
    public LinkedHashMap<Integer, Herramienta> actualizarStock(Scanner entrada, LinkedHashMap<Integer, Herramienta> inventarioTaller) {
    	if (inventarioTaller.isEmpty()) {
            System.out.println("Aun no hay empleados dados de alta en la empresa");
        } else {
            this.codigo = agregarInt(entrada,"codigo"); // Pide el código del empleado a actualizar

            // Verifica si el empleado con el código ingresado existe
            if (!inventarioTaller.containsKey(this.codigo)) {
                System.out.println("No hay ninguna herramienta con ese codigo en el taller");
            }else {
            	this.cantidad=agregarInt(entrada,"stock");
            	int cantidadPrevia=inventarioTaller.get(this.codigo).getCantidad();
            	// Actualiza el departamento en el LinkedHashMap con el código proporcionado
                inventarioTaller.get(this.codigo).setCantidad(inventarioTaller.get(this.codigo).getCantidad()+this.cantidad);
                
                System.out.println("Stock actualizado con exito");
                System.out.println("El stock de " + inventarioTaller.get(this.codigo).getNombre() + " pasa de " + cantidadPrevia + " unidades a " + inventarioTaller.get(this.codigo).getCantidad() + " unidades");

                
            }
            
        }
        
    	return inventarioTaller; // Retorna la lista actualizada

        
    }
    public LinkedHashMap<Integer, Herramienta> eliminarHerramienta(Scanner entrada, LinkedHashMap<Integer, Herramienta> inventarioTaller) {
        if (inventarioTaller.isEmpty()) {
            System.out.println("Aún no hay herramientas dadas de alta en el taller");
        } else {
            this.codigo = agregarInt(entrada,"codigo"); // Pide el código del empleado a eliminar

            // Verifica si el empleado con ese código existe en la lista
            if (!inventarioTaller.containsKey(this.codigo)) {
                System.out.println("No hay ningúna herramienta con ese código en la empresa");
            } else {
                char respuesta = ' ';

                // Confirma la eliminación del empleado con una respuesta del usuario
                while (true) {
                    System.out.println("¿Seguro que quieres borrar la herramienta " + inventarioTaller.get(this.codigo).getNombre() + " (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;
                    }
                }
                
                // Si la respuesta es afirmativa, elimina al empleado
                if (respuesta == 's') {
                	inventarioTaller.remove(this.codigo);
                    System.out.println("Herramienta borrada con éxito");
                } else {
                    System.out.println("Operación de borrado de herramienta abortada");
                }
            }
        }
        return inventarioTaller; // Retorna la lista actualizada
    }
	
    public void listarHerramientas(LinkedHashMap<Integer, Herramienta> inventarioTaller) {
        // Verifica si la lista está vacía
        if (inventarioTaller.isEmpty()) {
            System.out.println("Aun no hay herramientas dadas de alta en el taller");
        } else {
            
            System.out.println("Listado de herramientas en el taller");
            int cantidadHerramientas=0;
            // Recorre cada empleado en la lista e imprime sus datos
            for (Integer codigo : inventarioTaller.keySet()) {
                System.out.println("\nCodigo:" + codigo + inventarioTaller.get(codigo).toString());
                cantidadHerramientas+=inventarioTaller.get(codigo).getCantidad();
            }

            // Imprime el total de empleados listados
            System.out.println("Hay un total de " + inventarioTaller.size() + " herramientas diferentes en la empresa");
            System.out.println("Hay un total de " + cantidadHerramientas + " unidades de herramientas en la empresa");
        }
    }
    
    public void listarHerramientasCategorias(Scanner entrada, LinkedHashMap<Integer, Herramienta> inventarioTaller) {
        // Verifica si la lista está vacía
        if (inventarioTaller.isEmpty()) {
            System.out.println("Aun no hay herramientas dadas de alta en el taller");
        } else {
            this.categoria = campoTexto(entrada, "categoria"); // Pide el departamento

            boolean existeCategoria = false;

            // Verifica si hay empleados en el departamento especificado
            for (Integer codigo : inventarioTaller.keySet()) {
                if (inventarioTaller.get(codigo).getCategoria().equalsIgnoreCase(this.categoria)) {
                    existeCategoria = true;
                    break;
                }
            }
            if (!existeCategoria) {
                System.out.println("La categoria no existe en nuestra empresa");
            } else {
                int cuentoHerramientas = 0;
                System.out.println("Listado de herramientas de la categoria " + this.categoria + " en la empresa");
                
                int totalHerramientas=0;
                // Lista los empleados del departamento encontrado
                for (Integer codigo : inventarioTaller.keySet()) {
                    Herramienta herramienta = inventarioTaller.get(codigo);
                    if (herramienta.getCategoria().equalsIgnoreCase(this.categoria)) {
                        System.out.println("\nCodigo:" + codigo + herramienta.toString());
                        cuentoHerramientas++;
                        totalHerramientas+=inventarioTaller.get(codigo).getCantidad();
                    }
                }

                // Muestra el total de empleados en el departamento
                System.out.println("En la categoria " + this.categoria + " hay un total de " + cuentoHerramientas + " modelos de herramientas");
                System.out.println("En la categoria hayun total de " + totalHerramientas + " herramientas");
            }
        }
    }
    
    public void valorInventario(LinkedHashMap<Integer,Herramienta> inventarioTaller) {
    	if (inventarioTaller.isEmpty()) {
            System.out.println("Aun no hay herramientas dadas de alta en el taller");
        }else {
        	double valorTotal=0.0;
        	for (Integer codigo : inventarioTaller.keySet()) {
        		valorTotal+=(inventarioTaller.get(codigo).getCosto()*inventarioTaller.get(codigo).getCantidad());
        	}
        	
        	System.out.println("El valor total del inventario es:" + String.format("%.2f", valorTotal) + "€");
        }
    }
}


class MenuEjercicio5{
	LinkedHashMap<Integer,Herramienta> inventarioTaller=new LinkedHashMap<Integer,Herramienta>();
	Herramienta herramienta=new Herramienta();
	Scanner entrada=new Scanner(System.in);
	int menu=0;
	
	public void mostrarMenu() {
	     do {
	         // Muestra las opciones del menú
	         System.out.println("Menu Empleados");
	         System.out.println("1. Agregar herramienta");
	         System.out.println("2. Actualizar stock");
	         System.out.println("3. Eliminar herramienta");
	         System.out.println("4. Listar todas las herraientas");
	         System.out.println("5. Buscar herramientas por categoria");
	         System.out.println("6. Calcular valor total del inventario");
	         System.out.println("7. Salir");
	         System.out.println("Escoge opcion:");

	         try {
	             // Intenta capturar y convertir la entrada del usuario a entero
	             menu = Integer.parseInt(entrada.nextLine());
	             // Llama al método para gestionar la opción seleccionada
	             gestionarMenu(menu);
	         } catch (NumberFormatException e) {
	             // Muestra un mensaje de error si la entrada no es un número válido
	             System.err.println("Formato de menu no valido, introducelo de nuevo");
	         }
	     } while (menu != 7); // El menú se repite hasta que el usuario elija la opción 7 (Salir)
	 }

	 // Método para ejecutar la acción correspondiente a la opción seleccionada en el menú
	 private void gestionarMenu(int menu) {
	     switch (menu) {
	         case 1 -> inventarioTaller=herramienta.agregarHerramienta(entrada, inventarioTaller);
	         case 2 -> inventarioTaller=herramienta.actualizarStock(entrada, inventarioTaller);
	         case 3 -> inventarioTaller=herramienta.eliminarHerramienta(entrada, inventarioTaller);
	         case 4 -> herramienta.listarHerramientas(inventarioTaller);
	         case 5 -> herramienta.listarHerramientasCategorias(entrada, inventarioTaller);
	         case 6 -> herramienta.valorInventario(inventarioTaller);
	         case 7 -> {
	             // Mensaje de despedida y cierre del Scanner
	             System.out.println("Saliendo del programa de taller");
	             entrada.close();
	             break; // Termina la ejecución del menú
	         }
	         default -> // Mensaje para opciones no válidas en el menú
	             System.out.println("Opcion no contemplada en el menu, introducela de nuevo");
	     }
	 }
}