Carlos Fernández García

Ejercicio 1

Crea un programa que gestione una lista de nombres utilizando un Vector. El programa debe permitir al usuario realizar las siguientes acciones: 1. Añadir un nombre: Solicita al usuario que introduzca un nombre y añádelo al Vector. 2. Mostrar todos los nombres: Muestra en consola todos los nombres almacenados en el Vector. 3. Buscar un nombre: Permite al usuario introducir un nombre y verifica si existe en el Vector. Muestra un mensaje indicando si el nombre está presente o no. 4. Eliminar un nombre: Permite al usuario introducir un nombre y, si existe, eliminarlo del Vector. Si no existe, muestra un mensaje adecuado. 5. Salir del programa: Termina la ejecución del programa.


package vector;

import java.util.Iterator;
import java.util.Scanner;
import java.util.Vector;

public class Ejercicio1 {

    // Método principal que inicia el programa
    public static void main(String[] args) {
        MenuEjercicio1 menu = new MenuEjercicio1();  // Instancia de la clase MenuEjercicio1
        menu.mostrarMenu();  // Llama al método que muestra el menú interactivo
    }

}

// Clase que representa un nombre
class Nombre {
    String nombre;  // Atributo que almacena el nombre

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

    // Constructor que recibe el nombre como parámetro
    public Nombre(String nombre) {
        this.nombre = nombre;
    }

    // Método para obtener el nombre
    public String getNombre() {
        return nombre;
    }

    // Método para establecer el nombre
    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    // Método que devuelve la representación en cadena del objeto
    @Override
    public String toString() {
        return "\nNombre --> " + nombre;
    }

    // Método para agregar nombres al vector
    public Vector<Nombre> agregarNombres(Scanner entrada, Vector<Nombre> vectorNombres) {

        // Bucle para solicitar el nombre al usuario
        while (true) {
            System.out.println("Introduce un nombre:");
            this.nombre = entrada.nextLine();  // Captura el nombre ingresado

            // Verifica si el nombre está vacío
            if (this.nombre.equals("")) {
                System.out.println("El nombre no puede quedar vacio, introducelo de nuevo");
            } else {
                break;  // Sale del bucle si el nombre es válido
            }
        }

        // Crea un objeto Nombre y lo agrega al vector
        Nombre nombre = new Nombre(this.nombre);
        vectorNombres.add(nombre);

        return vectorNombres;  // Devuelve el vector actualizado
    }

    // Método para comprobar si el vector está vacío
    private boolean comprobarVector(Vector<Nombre> vectorNombres) {
        if (vectorNombres.isEmpty()) {
            System.out.println("El vector esta vacio");
            return false;  // El vector está vacío
        }
        return true;  // El vector no está vacío
    }

    // Método para mostrar todos los nombres del vector
    public void mostrarNombres(Vector<Nombre> vectorNombres) {
        if (!comprobarVector(vectorNombres)) {
            return;  // Si el vector está vacío, se sale del método
        } else {
            System.out.println("La lista de todos los nombres que estan en el vector:");
            for (Nombre nombre : vectorNombres) {  // Recorre el vector y muestra cada nombre
                System.out.println(nombre.getNombre());
            }
            System.out.println("Hay un total de " + vectorNombres.size() + " nombres en el vector");
        }
    }

    // Método para buscar un nombre en el vector
    public void buscarNombre(Scanner entrada, Vector<Nombre> vectorNombres) {
        if (!comprobarVector(vectorNombres)) {
            return;  // Si el vector está vacío, se sale del método
        } else {
            // Solicita al usuario el nombre a buscar
            while (true) {
                System.out.println("Introduce un nombre a buscar:");
                this.nombre = entrada.nextLine();

                if (this.nombre.equals("")) {
                    System.out.println("El nombre no puede quedar vacio, introducelo de nuevo");
                } else {
                    break;
                }
            }

            int index = 0;
            boolean nombreEncontrado = false;

            // Recorre el vector para buscar el nombre
            for (Nombre nombre : vectorNombres) {
                index++;
                if (nombre.getNombre().equalsIgnoreCase(this.nombre)) {
                    System.out.println(this.nombre + " encontrado en la posicion " + index + " del vector");
                    nombreEncontrado = true;
                }
            }

            // Si no encuentra el nombre, muestra un mensaje
            if (!nombreEncontrado) {
                System.out.println("El nombre no se encuentra en el vector");
            }
        }
    }

    // Método para eliminar un nombre del vector
    public Vector<Nombre> eliminarNombre(Scanner entrada, Vector<Nombre> vectorNombres) {
        if (!comprobarVector(vectorNombres)) {
            return vectorNombres;  // Si el vector está vacío, devuelve el mismo vector
        } else {
            // Solicita el nombre a eliminar
            while (true) {
                System.out.println("Introduce un nombre a borrar:");
                this.nombre = entrada.nextLine();

                if (this.nombre.equals("")) {
                    System.out.println("El nombre no puede quedar vacio, introducelo de nuevo");
                } else {
                    break;
                }
            }

            int index = 0;
            boolean nombreEncontrado = false;

            // Utiliza un iterador para eliminar el nombre del vector
            Iterator<Nombre> it = vectorNombres.iterator();

            while (it.hasNext()) {
                Nombre nombre = it.next();
                index++;
                if (nombre.getNombre().equals(this.nombre)) {
                    it.remove();  // Elimina el nombre si lo encuentra
                    System.out.println(this.nombre + " encontrado y borrado en la posicion " + index + " del vector");
                    nombreEncontrado = true;
                }
            }

            // Si no encuentra el nombre, muestra un mensaje
            if (!nombreEncontrado) {
                System.out.println("El nombre no se encuentra en el vector");
            }

            return vectorNombres;  // Devuelve el vector actualizado
        }
    }

}

// Clase que gestiona el menú del programa
class MenuEjercicio1 {
    Vector<Nombre> vectorNombres = new Vector<Nombre>();  // Vector que almacena objetos Nombre
    Nombre nombre = new Nombre();  // Instancia de la clase Nombre
    Scanner entrada = new Scanner(System.in);  // Objeto Scanner para entrada de datos
    int menu = 0;  // Variable para controlar el menú

    // Método que muestra el menú y gestiona las opciones del usuario
    public void mostrarMenu() {

        do {
            System.out.println("Menu nombres");
            System.out.println("(1).Añadir nombres");
            System.out.println("(2).Mostrar todos los nombres");
            System.out.println("(3).Buscar un nombre");
            System.out.println("(4).Eliminar un nombre");
            System.out.println("(5).Salir del programa");
            System.out.println("Escoge opcion:");

            try {
                menu = Integer.parseInt(entrada.nextLine());  // Captura la opción del menú
                gestionarMenu(menu);  // Llama al método para gestionar la opción seleccionada
            } catch (NumberFormatException e) {
                System.err.println("Formato de menu no valido, introducelo de nuevo");
            }
        } while (menu != 5);  // Bucle hasta que el usuario elija la opción de salir
    }

    // Método que gestiona las acciones del menú según la opción seleccionada
    private void gestionarMenu(int menu) {

        switch (menu) {
        case 1 -> vectorNombres = nombre.agregarNombres(entrada, vectorNombres);  // Añadir nombres
        case 2 -> nombre.mostrarNombres(vectorNombres);  // Mostrar nombres
        case 3 -> nombre.buscarNombre(entrada, vectorNombres);  // Buscar un nombre
        case 4 -> vectorNombres = nombre.eliminarNombre(entrada, vectorNombres);  // Eliminar un nombre
        case 5 -> {
            System.out.println("Saliendo del programa");
            entrada.close();  // Cerrar el Scanner al salir del programa
        }
        default -> System.out.println("Opcion no contemplada, introducela de nuevo");
        }
    }
}

Ejercicio 2

Crea un programa en Java para gestionar un grupo de estudiantes utilizando la clase Vector. El programa debe permitir realizar las siguientes operaciones: Añadir un estudiante: Cada estudiante debe tener un nombre, un número de identificación y una calificación final. Al agregar un nuevo estudiante, estos datos deben ser solicitados al usuario. Mostrar la lista de estudiantes: Muestra todos los estudiantes almacenados en el Vector con sus respectivos datos. Eliminar un estudiante por identificación: Permite eliminar a un estudiante del Vector proporcionando su número de identificación. Actualizar la calificación de un estudiante: Permite buscar a un estudiante por su número de identificación y actualizar su calificación. Mostrar el promedio de las calificaciones: Calcula y muestra la calificación promedio de todos los estudiantes. Salir: Finaliza el programa.

package vector;

import java.util.Iterator;
import java.util.Scanner;
import java.util.Vector;

public class Ejercicio2 {

	public static void main(String[] args) {
		
		MenuEstudiante menu = new MenuEstudiante(); // Crea una instancia del menú de estudiantes
		menu.mostrarMenu(); // Muestra el menú al usuario

	}

}

class Estudiante {
	String nombre; // Nombre del estudiante
	int identificacion; // Número de identificación del estudiante
	double calificacion; // Calificación del estudiante
	
	private static int contadorIdentificacion = 0; // Contador para las identificaciones de estudiantes

	public Estudiante() {
		this.identificacion = contadorIdentificacion++; // Asigna una identificación al nuevo estudiante
	}

	public Estudiante(String nombre, double calificacion) {
		this.nombre = nombre; // Asigna el nombre al estudiante
		this.calificacion = calificacion; // Asigna la calificación al estudiante
		this.identificacion = contadorIdentificacion++; // Asigna una identificación al nuevo estudiante
	}

	public String getNombre() {
		return nombre; // Devuelve el nombre del estudiante
	}

	public void setNombre(String nombre) {
		this.nombre = nombre; // Establece el nombre del estudiante
	}

	public double getCalificacion() {
		return calificacion; // Devuelve la calificación del estudiante
	}

	public void setCalificacion(double calificacion) {
		this.calificacion = calificacion; // Establece la calificación del estudiante
	}

	public int getIdentificacion() {
		return identificacion; // Devuelve la identificación del estudiante
	}

	@Override
	public String toString() {
		return "\nNombre --> " + nombre + "\nIdentificacion --> " + identificacion + "\nCalificacion --> " + calificacion; // Representación en cadena del estudiante
	}
	
	// Método para agregar un nuevo estudiante a la lista
	public Vector<Estudiante> agregarEstudiante(Scanner entrada, Vector<Estudiante> listaEstudiantes) {
		
		// Solicitar el nombre del estudiante
		while (true) {
			System.out.println("Introduce el nombre del estudiante:");
			this.nombre = entrada.nextLine();
			
			if (this.nombre.equals("")) {
				System.out.println("El nombre no puede quedar en blanco, introducelo de nuevo"); // Mensaje de error si el nombre está vacío
			} else {
				break; // Salir del bucle si el nombre es válido
			}
		}
		
		// Solicitar la calificación del estudiante
		while (true) {
			
			try {
				System.out.println("Introducela calificacion de " + this.nombre.toString());
				this.calificacion = Double.parseDouble(entrada.nextLine());

			} catch (NumberFormatException e) {
				System.err.println("Formato de calificacion invalido, introducela de nuevo"); // Mensaje de error si el formato es inválido
			}
			
			if (this.calificacion < 0 || this.calificacion > 10) {
				System.out.println("La calificacion tienes que estar comprendida entre 0 y 10, introducela de nuevo"); // Mensaje si la calificación está fuera del rango
			} else {
				break; // Salir del bucle si la calificación es válida
			}
		}
		
		Estudiante estudiante = new Estudiante(this.nombre, this.calificacion); // Crear un nuevo objeto Estudiante
		listaEstudiantes.add(estudiante); // Agregar el estudiante a la lista
		
		System.out.println("Estudiante dado de alta correctamente"); // Mensaje de confirmación
		
		return listaEstudiantes; // Devolver la lista actualizada
	}
	
	// Método para comprobar si hay estudiantes en la lista
	private boolean comprobarListaEstudiantes(Vector<Estudiante> listaEstudiantes) {
		if (listaEstudiantes.isEmpty()) {
			System.out.println("No hay estudiantes dados de alta"); // Mensaje si la lista está vacía
			return false; // Devuelve falso si no hay estudiantes
		} else {
			return true; // Devuelve verdadero si hay estudiantes
		}
	}
	
	// Método para mostrar la lista de estudiantes
	public void mostrarEstudiantes(Vector<Estudiante> listaEstudiantes) {
		if (!comprobarListaEstudiantes(listaEstudiantes)) {
			return; // Si no hay estudiantes, salir del método
		} else {
			System.out.println("Lista de todos los estudiantes"); // Mensaje de encabezado
			for (Estudiante estudiante : listaEstudiantes) {
				System.out.println(estudiante.toString()); // Mostrar cada estudiante en la lista
			}
			System.out.println("Hay un total de " + listaEstudiantes.size() + " estudiantes"); // Mostrar el total de estudiantes
		}
	}
	
	// Método para eliminar un estudiante de la lista
	public Vector<Estudiante> eliminarEstudiante(Scanner entrada, Vector<Estudiante> listaEstudiantes) {
		if (!comprobarListaEstudiantes(listaEstudiantes)) {
			return listaEstudiantes; // Si no hay estudiantes, devolver la lista sin cambios
		} else {
			
			// Solicitar la identificación del estudiante a eliminar
			while (true) {
				
				try {
					System.out.println("Introduce el numero de identificacion del estudiante a borrar");
					this.identificacion = Integer.parseInt(entrada.nextLine());
				} catch (NumberFormatException e) {
					System.out.println("Formato de numero de identificaion invalido, introducelo de nuevo"); // Mensaje de error si el formato es inválido
				}
				
				if (this.identificacion < 1) {
					System.out.println("El numero de identificacion no puede ser menor que 1, introducelo de nuevo"); // Mensaje si la identificación es inválida
				} else {
					break; // Salir del bucle si la identificación es válida
				}
			}	
				boolean encontradoEstudiante = false; // Variable para comprobar si se encontró el estudiante
				Iterator<Estudiante> it = listaEstudiantes.iterator(); // Crear un iterador para la lista de estudiantes
				char respuesta = ' ';
				while (it.hasNext()) {
					Estudiante estudiante = it.next();
					
					if (estudiante.getIdentificacion() == this.identificacion) {
						while (true) {
							System.out.println("¿Seguro que quieres borrar al estudiante " + estudiante.getNombre() + "? (s)i/(n)o");
							respuesta = entrada.nextLine().toLowerCase().charAt(0);
							
							if (respuesta != 's' && respuesta != 'n') {
								System.out.println("La respuesta tiene que ser (s)i o (n)o, introducela de nuevo"); // Mensaje de error si la respuesta es inválida
							} else {
								break; // Salir del bucle si la respuesta es válida
							}
						}
						encontradoEstudiante = true; // Se encontró el estudiante
						if (respuesta == 's') {
							System.out.println("El estudiante " + estudiante.getNombre() + " sera borrado"); // Mensaje de confirmación
							it.remove(); // Eliminar el estudiante de la lista
						} else {
							System.out.println("La operacion de borrar al estudiante " + estudiante.getNombre() + " ha sido cancelada"); // Mensaje de cancelación
						}
					}
				}
				
				if (!encontradoEstudiante) {
					System.out.println("Ningun estudiante en la lista con ese numero de identificacion"); // Mensaje si no se encuentra el estudiante
				}
			
			
			return listaEstudiantes; // Devolver la lista actualizada
		}

	}
	
	// Método para actualizar la calificación de un estudiante
	public Vector<Estudiante> actualizarEstudiante(Scanner entrada, Vector<Estudiante> listaEstudiantes) {
		if (!comprobarListaEstudiantes(listaEstudiantes)) {
			return listaEstudiantes; // Si no hay estudiantes, devolver la lista sin cambios
		} else {
			while (true) {
				
				try {
					System.out.println("Introduce el numero de identificacion del estudiante a actualizar");
					this.identificacion = Integer.parseInt(entrada.nextLine());
				} catch (NumberFormatException e) {
					System.out.println("Formato de numero de identificaion invalido, introducelo de nuevo"); // Mensaje de error si el formato es inválido
				}
				
				if (this.identificacion < 1) {
					System.out.println("El numero de identificacion no puede ser menor que 1, introducelo de nuevo"); // Mensaje si la identificación es inválida
				} else {
					break; // Salir del bucle si la identificación es válida
				}
			}	
				boolean encontradoEstudiante = false; // Variable para comprobar si se encontró el estudiante
				
				char respuesta = ' ';
				for (Estudiante estudiante : listaEstudiantes) {
					
					if (estudiante.getIdentificacion() == this.identificacion) {
						encontradoEstudiante = true; // Se encontró el estudiante
						while (true) {
							System.out.println("¿Seguro que quieres actualizar al estudiante " + estudiante.getNombre() + "? (s)i/(n)o");
							respuesta = entrada.nextLine().toLowerCase().charAt(0);
							
							if (respuesta != 's' && respuesta != 'n') {
								System.out.println("La respuesta tiene que ser (s)i o (n)o, introducela de nuevo"); // Mensaje de error si la respuesta es inválida
							} else {
								break; // Salir del bucle si la respuesta es válida
							}
						}
						if (respuesta == 's') {
							
							// Solicitar la nueva calificación del estudiante
							while (true) {
								
								try {
									System.out.println("Introduce la nueva calificacion de " + estudiante.getNombre());
									this.calificacion = Double.parseDouble(entrada.nextLine());

								} catch (NumberFormatException e) {
									System.err.println("Formato de calificacion invalido, introducela de nuevo"); // Mensaje de error si el formato es inválido
								}
								
								if (this.calificacion < 0 || this.calificacion > 10) {
									System.out.println("La calificacion tienes que estar comprendida entre 0 y 10, introducela de nuevo"); // Mensaje si la calificación está fuera del rango
								} else {
									break; // Salir del bucle si la calificación es válida
								}
							}
							
							estudiante.setCalificacion(this.calificacion); // Actualizar la calificación del estudiante
							System.out.println("El estudiante " + estudiante.getNombre() + " ha sido actualizado"); // Mensaje de confirmación
						} else {
							System.out.println("La operacion de actualizar al estudiante " + estudiante.getNombre() + " ha sido cancelada"); // Mensaje de cancelación
						}
					}
					
				}
					
				if (!encontradoEstudiante) {
					System.out.println("Ningun estudiante en la lista con ese numero de identificacion"); // Mensaje si no se encuentra el estudiante
				}
			
			return listaEstudiantes; // Devolver la lista actualizada
		}
		
	}
	
	// Método para calcular y mostrar el promedio de calificaciones
	public void mediaEstudiantes(Vector<Estudiante> listaEstudiantes) {
		if (!comprobarListaEstudiantes(listaEstudiantes)) {
			return; // Si no hay estudiantes, salir del método
		} else {
			double sumaNotas = 0.0; // Variable para acumular las calificaciones
			for (Estudiante estudiante : listaEstudiantes) {
				sumaNotas += estudiante.getCalificacion(); // Sumar la calificación de cada estudiante
			}
			
			System.out.println("La nota media de los estudiantes es --> " + String.format("%.2f", sumaNotas / listaEstudiantes.size())); // Mostrar el promedio
		}
	}
	
}

class MenuEstudiante {
	Vector<Estudiante> listaEstudiantes = new Vector<Estudiante>(); // Lista para almacenar estudiantes
	Estudiante estudiante = new Estudiante(); // Crear un objeto Estudiante para gestionar operaciones
	Scanner entrada = new Scanner(System.in); // Scanner para la entrada de datos
	int menu = 0; // Variable para almacenar la opción del menú
	
	// Método para mostrar el menú de opciones
	public void mostrarMenu() {
		
		do {
			System.out.println("MENU ESTUDIANTES");
			System.out.println("(1).Agregar nuevo estudiante");
			System.out.println("(2).Mostrar lista de estudiantes");
			System.out.println("(3).Eliminar estudiante por indentificacion");
			System.out.println("(4).Actualizar calificacion de estudiante");
			System.out.println("(5).Mostrar promedio de calificacion");
			System.out.println("(6).Salir del programa");
			System.out.println("Escoge opcion:");
			
			try {
				menu = Integer.parseInt(entrada.nextLine()); // Leer opción del menú
				gestionarMenu(menu); // Gestionar la opción seleccionada
			} catch (NumberFormatException e) {
				System.err.println("Formato de menu invalido, introducelo de nuevo"); // Mensaje de error si el formato es inválido
			}
		} while (menu != 6); // Continuar hasta que se elija salir
	}
	
	// Método para gestionar la opción seleccionada en el menú
	public void gestionarMenu(int menu) {
		
		switch (menu) {
		case 1 -> listaEstudiantes = estudiante.agregarEstudiante(entrada, listaEstudiantes); // Agregar nuevo estudiante
		case 2 -> estudiante.mostrarEstudiantes(listaEstudiantes); // Mostrar lista de estudiantes
		case 3 -> listaEstudiantes = estudiante.eliminarEstudiante(entrada, listaEstudiantes); // Eliminar estudiante
		case 4 -> listaEstudiantes = estudiante.actualizarEstudiante(entrada, listaEstudiantes); // Actualizar calificación de estudiante
		case 5 -> estudiante.mediaEstudiantes(listaEstudiantes); // Mostrar promedio de calificaciones
		case 6 -> {
			System.out.println("Saliendo del programa"); // Mensaje al salir del programa
			entrada.close(); // Cerrar el scanner
		}
		default -> System.out.println("Opcion no contemplada en el menu, introducela de nuevo"); // Mensaje si la opción es inválida
		}
	}
}

Ejercicio 3

Crea un programa en Java que gestione una biblioteca de películas utilizando la clase Vector. El programa debe permitir realizar las siguientes operaciones: Añadir una película: Cada película debe tener un título, un año de lanzamiento y una calificación (de 0 a 10). Solicita estos datos al usuario para agregar nuevas películas al Vector. Mostrar la lista de películas: Muestra todas las películas almacenadas en el Vector con sus respectivos detalles. Buscar una película por título: Permite buscar una película en la colección por su título. Si se encuentra, muestra los detalles de la película. Eliminar una película por título: Elimina una película de la biblioteca proporcionando su título. Actualizar la calificación de una película: Permite buscar una película por su título y actualizar su calificación. Mostrar el promedio de las calificaciones de las películas: Calcula y muestra la calificación promedio de todas las películas almacenadas. Salir: Finaliza el programa.


package vector;

import java.time.LocalDate;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Vector;

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

class Pelicula {
    String titulo;
    int anio;
    int calificacion;

    public Pelicula() {
    }

    public Pelicula(String titulo, int anio, int calificacion) {
        this.titulo = titulo;
        this.anio = anio;
        this.calificacion = calificacion;
    }

    public String getTitulo() {
        return titulo;
    }

    public void setTitulo(String titulo) {
        this.titulo = titulo;
    }

    public int getAnio() {
        return anio;
    }

    public void setAnio(int anio) {
        this.anio = anio;
    }

    public int getCalificacion() {
        return calificacion;
    }

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

    @Override
    public String toString() {
        return "\nTitulo -->" + titulo + "\nAño --> " + anio + "\nCalificacion --> " + calificacion;
    }

    // Convierte la primera letra de un título a mayúsculas y el resto a minúsculas
    private String mayusculas(String dato) {
        return dato.substring(0, 1).toUpperCase() + dato.substring(1).toLowerCase();
    }

    // Método para agregar un título de película asegurándose que no esté vacío
    private String agregarTitulo(Scanner entrada) {
        String dato = "";
        while (true) {
            System.out.println("Introduce el titulo de la pelicula");
            dato = entrada.nextLine();
            if (dato.equals("")) {
                System.out.println("El titulo de la pelicula no puede quedar vacio, introducelo de nuevo");
            } else {
                dato = mayusculas(dato);
                return dato;
            }
        }
    }

    // Método para solicitar y validar el año de lanzamiento de la película
    private int anioLanzamiento(Scanner entrada) {
        int dato = 0;

        while (true) {
            try {
                System.out.println("Introduce el año de lanzamiento de la pelicula");
                dato = Integer.parseInt(entrada.nextLine());
                int anioActual = LocalDate.now().getYear();
                if (dato < 1895) {
                    System.out.println("La pelicula no puede ser anterior a 1895 fecha de lanzamiento de la pelicula de los hermanos Lumiere, introducela de nuevo");
                } else if (dato > anioActual) {
                    System.out.println("La fecha de lanzamiento no puede ser mayor que el año actual que es " + anioActual + ", introducela de nuevo");
                } else {
                    return dato;
                }
            } catch (NumberFormatException e) {
                System.err.println("Formato de año no valido, introducelo de nuevo");
            }
        }
    }

    // Método para solicitar y validar la calificación de la película
    private int agregarCalificacion(Scanner entrada) {
        int dato = 0;

        while (true) {
            try {
                System.out.println("Introduce la calificacion de la pelicula entre 0 y 10");
                dato = Integer.parseInt(entrada.nextLine());
                if (dato < 0 || dato > 10) {
                    System.out.println("La calificacion de la pelicula tiene que ser entre 0 y 10, introducela de nuevo");
                } else {
                    return dato;
                }
            } catch (NumberFormatException e) {
                System.err.println("Formato de calificacion no valido, introducelo de nuevo");
            }
        }
    }

    // Método para agregar una película a la lista
    public Vector<Pelicula> agregarPelicula(Scanner entrada, Vector<Pelicula> listaPeliculas) {
        this.titulo = agregarTitulo(entrada);
        this.anio = anioLanzamiento(entrada);
        this.calificacion = agregarCalificacion(entrada);

        Pelicula pelicula = new Pelicula(this.titulo, this.anio, this.calificacion);
        listaPeliculas.add(pelicula);
        System.out.println("Pelicula agregada correctamente a la lista");

        return listaPeliculas;
    }

    // Método para comprobar si la lista de películas está vacía
    private boolean comprobarListaPeliculas(Vector<Pelicula> listaPeliculas) {
        if (listaPeliculas.isEmpty()) {
            System.out.println("La lista de peliculas esta vacia");
            return false;
        } else {
            return true;
        }
    }

    // Método para mostrar la lista de películas
    public void mostrarListaPeliculas(Vector<Pelicula> listaPeliculas) {
        if (!comprobarListaPeliculas(listaPeliculas)) {
            return;
        } else {
            System.out.println("Listado de peliculas en la lista");
            for (Pelicula pelicula : listaPeliculas) {
                System.out.println(pelicula.toString());
            }
        }
    }

    // Método para buscar una película por título
    public void buscarPelicula(Scanner entrada, Vector<Pelicula> listaPeliculas) {
        if (!comprobarListaPeliculas(listaPeliculas)) {
            return;
        } else {
            this.titulo = agregarTitulo(entrada);
            int vecesEncontrada = 0;

            for (Pelicula pelicula : listaPeliculas) {
                if (pelicula.getTitulo().equalsIgnoreCase(this.titulo)) {
                    vecesEncontrada++;
                    System.out.println(pelicula.toString());
                }
            }

            if (vecesEncontrada == 0) {
                System.out.println("La pelicula no se encuentra en la lista");
            } else if (vecesEncontrada == 1) {
                System.out.println("Pelicula encontrada 1 vez en la lista");
            } else {
                System.out.println("Pelicula encontrada " + vecesEncontrada + " veces en la lista");
            }
        }
    }

    // Método para actualizar la calificación de una película
    public Vector<Pelicula> actualizarPelicula(Scanner entrada, Vector<Pelicula> listaPeliculas) {
        if (!comprobarListaPeliculas(listaPeliculas)) {
            return listaPeliculas;
        } else {
            this.titulo = agregarTitulo(entrada);
            int vecesEncontrada = 0;

            for (Pelicula pelicula : listaPeliculas) {
                if (pelicula.getTitulo().equalsIgnoreCase(this.titulo)) {
                    vecesEncontrada++;
                    this.calificacion = agregarCalificacion(entrada);
                    pelicula.setCalificacion(this.calificacion);
                    if (vecesEncontrada == 1) {
                        System.out.println("La pelicula ha sido actualizada 1 vez en la lista");
                    } else {
                        System.out.println("La pelicula ha sido actualizada " + vecesEncontrada + " veces en la lista");
                    }
                }
            }

            if (vecesEncontrada == 0) {
                System.out.println("La pelicula no se encuentra en la lista");
            }

            return listaPeliculas;
        }
    }

    // Método para eliminar una película por título
    public Vector<Pelicula> eliminarPelicula(Scanner entrada, Vector<Pelicula> listaPeliculas) {
        if (!comprobarListaPeliculas(listaPeliculas)) {
            return listaPeliculas;
        } else {
            this.titulo = agregarTitulo(entrada);
            int vecesEncontrada = 0;

            Iterator<Pelicula> it = listaPeliculas.iterator();

            while (it.hasNext()) {
                Pelicula pelicula = it.next();
                if (pelicula.getTitulo().equals(this.titulo)) {
                    vecesEncontrada++;
                    it.remove();
                }
            }

            if (vecesEncontrada == 0) {
                System.out.println("La pelicula no se encuentra en la lista");
            } else if (vecesEncontrada == 1) {
                System.out.println("La pelicula ha sido borrada 1 vez en la lista");
            } else {
                System.out.println("La pelicula ha sido borrada " + vecesEncontrada + " veces en la lista");
            }

            return listaPeliculas;
        }
    }

    // Método para calcular y mostrar el promedio de calificaciones
    public void calcularPromedio(Vector<Pelicula> listaPeliculas) {
        if (!comprobarListaPeliculas(listaPeliculas)) {
            return;
        } else {
            double promedio = 0;
            double sumaCalificaciones = 0;

            for (Pelicula pelicula : listaPeliculas) {
                sumaCalificaciones += pelicula.getCalificacion();
            }

            promedio = sumaCalificaciones / listaPeliculas.size();
            System.out.println("El promedio de calificaciones es: " + promedio);
        }
    }
}

class MenuEjercicio3 {
    private Pelicula pelicula = new Pelicula();

    public void mostrarMenu() {
        Vector<Pelicula> listaPeliculas = new Vector<>();
        Scanner entrada = new Scanner(System.in);
        int opcion;

        do {
            // Muestra el menú de opciones al usuario
            System.out.println("\n--- MENU DE OPCIONES ---");
            System.out.println("1. Añadir película");
            System.out.println("2. Mostrar lista de películas");
            System.out.println("3. Buscar película por título");
            System.out.println("4. Eliminar película por título");
            System.out.println("5. Actualizar calificación de película");
            System.out.println("6. Mostrar promedio de calificaciones");
            System.out.println("7. Salir");
            System.out.println("Seleccione una opción:");
            opcion = Integer.parseInt(entrada.nextLine());

            // Maneja la opción seleccionada utilizando un switch
            switch (opcion) {
                case 1 -> listaPeliculas = pelicula.agregarPelicula(entrada, listaPeliculas);
                case 2 -> pelicula.mostrarListaPeliculas(listaPeliculas);
                case 3 -> pelicula.buscarPelicula(entrada, listaPeliculas);
                case 4 -> listaPeliculas = pelicula.eliminarPelicula(entrada, listaPeliculas);
                case 5 -> listaPeliculas = pelicula.actualizarPelicula(entrada, listaPeliculas);
                case 6 -> pelicula.calcularPromedio(listaPeliculas);
                case 7 -> {
                	System.out.println("Saliendo del programa...");
                	// Cierra el Scanner al final del programa
                    entrada.close();
                }
                default -> System.out.println("Opción no válida, por favor intente de nuevo.");
            }
        } while (opcion != 7);
        
        
    }
}

Ejercicio 4

Crea un programa en Java que gestione un inventario de productos utilizando la clase Vector. El programa debe permitir realizar las siguientes operaciones: Registrar Productos: Cada producto debe tener un nombre, un código de producto único y un precio. Solicita estos datos al usuario para registrar nuevos productos en el inventario. Mostrar Inventario: Muestra todos los productos almacenados en el inventario con sus respectivos detalles (nombre, código y precio). Buscar Producto por Código: Permite buscar un producto en el inventario por su código de producto. Si se encuentra, muestra los detalles del producto. Modificar Precio de un Producto: Permite buscar un producto por su código y modificar su precio. Calcular Total del Inventario: Calcula y muestra el valor total del inventario, sumando los precios de todos los productos registrados. Mostrar Productos en Rango de Precio: Permite al usuario ingresar un rango de precios (mínimo y máximo) y muestra todos los productos cuyo precio se encuentre dentro de ese rango. Salir: Finaliza el programa.


package vector;

import java.util.Scanner;
import java.util.Vector;

public class Ejercicio4 {

    public static void main(String[] args) {
        MenuEjercicio4 menu = new MenuEjercicio4();  // Se crea una instancia del menú.
        menu.muestroMenu();  // Se llama al método que muestra el menú.
    }

}

class Producto {
    String nombre;
    int codigo;
    double precio;
    
    private static int generadorCodigo = 1;  // Variable estática para generar códigos únicos.
    
    public Producto() {
        // Constructor vacío
    }

    public Producto(String nombre, double precio) {
        this.nombre = nombre;  // Inicializa el nombre.
        this.codigo = generadorCodigo++;  // Asigna un código único e incrementa el generador.
        this.precio = precio;  // Inicializa el precio.
    }

    public String getNombre() {
        return nombre;  // Retorna el nombre del producto.
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;  // Permite modificar el nombre del producto.
    }

    public double getPrecio() {
        return precio;  // Retorna el precio del producto.
    }

    public void setPrecio(double precio) {
        this.precio = precio;  // Permite modificar el precio del producto.
    }

    public int getCodigo() {
        return codigo;  // Retorna el código del producto.
    }

    @Override
    public String toString() {
        // Devuelve una cadena con los detalles del producto.
        return "\nNombre --> " + nombre + "\nCodigo --> " + codigo + "\nPrecio --> " + String.format("%.2f", precio) + "€";
    }

    private String pongoMayuscula(String dato) {
        // Convierte la primera letra en mayúscula y el resto en minúsculas.
        return dato.substring(0, 1).toUpperCase() + dato.substring(1).toLowerCase();
    }

    private String campoTexto(Scanner entrada) {
        String dato = "";
        while (true) {
            System.out.println("Introduce el nombre del producto:");
            dato = entrada.nextLine();
            
            // Verifica si el nombre está vacío.
            if (dato.equals("")) {
                System.out.println("El nombre del producto no puede quedar vacio, introducelo de nuevo");
            } else {
                return dato = pongoMayuscula(dato);  // Pone la primera letra en mayúscula.
            }
        }
    }

    private double campoDoble(Scanner entrada) {
        double dato = 0;
        while (true) {
            try {
                System.out.println("Introduce el precio del producto:");
                dato = Double.parseDouble(entrada.nextLine());
                
                // Verifica si el precio es válido.
                if (dato < 0.01) {
                    System.out.println("El precio no puede ser inferior a 1 centimo de €");
                } else {
                    return dato;
                }
            } catch (NumberFormatException e) {
                System.out.println("Formato de precio incorrecto, introducelo de nuevo");
            }
        }
    }

    private int campoEntero(Scanner entrada) {
        int dato = 0;
        while (true) {
            try {
                System.out.println("Introduce el codigo del producto:");
                dato = Integer.parseInt(entrada.nextLine());
                
                // Verifica si el código es válido.
                if (dato < 1) {
                    System.out.println("El codigo no puede ser inferior a 1");
                } else {
                    return dato;
                }
            } catch (NumberFormatException e) {
                System.out.println("Formato de codigo incorrecto, introducelo de nuevo");
            }
        }
    }

    public Vector<Producto> agregarProducto(Scanner entrada, Vector<Producto> listaProductos) {
        // Captura el nombre y el precio del producto a través de métodos.
        this.nombre = campoTexto(entrada);
        this.precio = campoDoble(entrada);
        
        Producto producto = new Producto(this.nombre, this.precio);  // Crea un nuevo producto.
        listaProductos.add(producto);  // Añade el producto a la lista.
        System.out.println("Producto dado de alta correctamente");
        return listaProductos;
    }

    private boolean comprobarInventario(Vector<Producto> listaProductos) {
        // Verifica si el inventario está vacío.
        if (listaProductos.isEmpty()) {
            System.out.println("El inventario esta vacio aun");
            return false;
        } else {
            return true;
        }
    }

    public void mostrarInventario(Vector<Producto> listaProductos) {
        // Muestra todos los productos del inventario.
        if (!comprobarInventario(listaProductos)) {
            return;
        } else {
            System.out.println("Lista de todos los productos");
            for (Producto producto : listaProductos) {
                System.out.println(producto.toString());
            }
        }
    }

    public void buscarProducto(Scanner entrada, Vector<Producto> listaProductos) {
        // Busca un producto por su código.
        if (!comprobarInventario(listaProductos)) {
            return;
        } else {
            this.codigo = campoEntero(entrada);
            
            boolean encontradoProducto = false;
            
            for (Producto producto : listaProductos) {
                if (producto.getCodigo() == this.codigo) {
                    encontradoProducto = true;
                    System.out.println("Detalles el producto buscado:" + producto.toString());
                }
            }
            
            if (!encontradoProducto) {
                System.out.println("El producto no se encuentra en el inventario");
            }
        }
    }

    public Vector<Producto> modificarPrecio(Scanner entrada, Vector<Producto> listaProductos) {
        // Modifica el precio de un producto.
        if (!comprobarInventario(listaProductos)) {
            return listaProductos;
        } else {
            this.codigo = campoEntero(entrada);
            
            boolean encontradoProducto = false;
            
            for (Producto producto : listaProductos) {
                if (producto.getCodigo() == this.codigo) {
                    char respuesta = ' ';
                    
                    while (true) {
                        System.out.println("¿Estas seguro que quieres modificar el precio del producto " + producto.getNombre().toString() + "?(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;
                        }
                    }
                    if (respuesta == 'n') {
                        System.out.println("Operacion de actualizacion de precio abortada");
                    } else {
                        this.precio = campoDoble(entrada);  // Captura el nuevo precio.
                        producto.setPrecio(this.precio);  // Actualiza el precio del producto.
                        System.out.println("El precio del producto " + producto.getNombre().toString() + " ha sido actualizado con exito");
                    }
                }
            }
            
            if (!encontradoProducto) {
                System.out.println("El producto no se encuentra en el inventario");
            }
            return listaProductos;
        }
    }

    public void calcularInventario(Vector<Producto> listaProductos) {
        // Calcula el valor total de todos los productos del inventario.
        if (!comprobarInventario(listaProductos)) {
            return;
        } else {
            mostrarInventario(listaProductos);
            double sumaPrecio = 0.0;
            
            for (Producto producto : listaProductos) {
                sumaPrecio += producto.getPrecio();
            }
            
            System.out.println("Hay un total de " + listaProductos.size() + " productos en el inventario y su valor suma " +
            String.format("%.2f", sumaPrecio) + "€");
        }
    }

    public void mostrarRangoPrecios(Scanner entrada, Vector<Producto> listaProductos) {
        // Muestra productos que están dentro de un rango de precios.
        if (!comprobarInventario(listaProductos)) {
            return;
        } else {
            double precioMenor = campoDoble(entrada);
            double precioMayor = 0.0;
            do {
                precioMayor = campoDoble(entrada);
                
                if (precioMayor < precioMenor) {
                    System.out.println("El precio mayor tiene que ser mayor o igual que el precio menor");
                }
            } while (precioMenor > precioMayor);
            
            int contadorProductos = 0;
            for (Producto producto : listaProductos) {
                if (producto.getPrecio() >= precioMenor && producto.getPrecio() <= precioMayor) {
                    System.out.println(producto.toString());
                    contadorProductos++;
                }
            }
            
            if (contadorProductos == 0) {
                System.out.println("Ningun producto entre " + precioMenor + "€ y " + precioMayor + "€");
            } else if (contadorProductos == 1) {
                System.out.println("1 producto entre " + precioMenor + "€ y " + precioMayor + "€");
            } else {
                System.out.println(contadorProductos + " productos entre " + precioMenor + "€ y " + precioMayor + "€");
            }
        }
    }
}

class MenuEjercicio4 {
    Vector<Producto> listaProductos = new Vector<Producto>();  // Lista que almacena los productos.
    Producto producto = new Producto();  // Instancia de producto.
    int menu = 0;
    Scanner entrada = new Scanner(System.in);  // Para capturar las entradas del usuario.
    
    public void muestroMenu() {
        // Muestra el menú principal y gestiona las opciones seleccionadas.
        do {
            System.out.println("(1).Añadir producto");
            System.out.println("(2).Mostrar inventario");
            System.out.println("(3).Buscar producto por código");
            System.out.println("(4).Modificar precio de producto");
            System.out.println("(5).Calcular valor total del inventario");
            System.out.println("(6).Mostrar productos en un rango de precio");
            System.out.println("(7).Salir del programa...");
            System.out.println("Escoger opcion:");
            
            try {
                menu = Integer.parseInt(entrada.nextLine());  // Captura la opción del usuario.
                gestionoMenu(menu);  // Llama al método que gestiona las opciones del menú.
            } catch (NumberFormatException e) {
                System.err.println("Formato de menu no valido, introducelo de nuevo");
            }
        } while (menu != 7);  // El menú se repite hasta que se seleccione la opción 7 (salir).
    }
    
    public void gestionoMenu(int menu) {
        // Gestiona las opciones seleccionadas por el usuario.
        switch (menu) {
        case 1 -> listaProductos = producto.agregarProducto(entrada, listaProductos);  // Añade un producto.
        case 2 -> producto.mostrarInventario(listaProductos);  // Muestra todos los productos.
        case 3 -> producto.buscarProducto(entrada, listaProductos);  // Busca un producto por su código.
        case 4 -> listaProductos = producto.modificarPrecio(entrada, listaProductos);  // Modifica el precio de un producto.
        case 5 -> producto.calcularInventario(listaProductos);  // Calcula el valor total del inventario.
        case 6 -> producto.mostrarRangoPrecios(entrada, listaProductos);  // Muestra productos dentro de un rango de precios.
        case 7 -> {
            System.out.println("Saliendo del programa");
            entrada.close();  // Cierra el Scanner al salir del programa.
            break;
        }
        default -> System.out.println("Opcion no contemplada en el menu, introducela de nuevo");  // Maneja opciones inválidas.
        }
    }
}

Ejercicio 5

Desarrolla un programa en Java que gestione un inventario de productos organizados por categorías. El sistema debe permitir al usuario crear, eliminar y listar categorías, y dentro de cada categoría, añadir productos. Para cada categoría y su lista de productos, utiliza la clase Vector. Requisitos: El programa debe permitir gestionar varias categorías de productos. Cada categoría es representada por un nombre y su respectivo Vector de productos. Cada producto tendrá un nombre, un precio y una cantidad en stock. Funcionalidades del programa: Crear una nueva categoría. Eliminar una categoría específica (y todos sus productos). Listar todas las categorías existentes. Dentro de una categoría, agregar nuevos productos. Mostrar todos los productos de una categoría seleccionada, con su información (nombre, precio y stock). Buscar y mostrar un producto específico dentro de una categoría (basado en el nombre del producto). Calcular el valor total en stock de una categoría (suma del precio multiplicado por la cantidad de cada producto). El programa debe funcionar mediante un menú interactivo que se repita hasta que el usuario elija salir.


package vector;

import java.util.Iterator;
import java.util.Scanner;
import java.util.Vector;

public class Ejercicio5 {

    public static void main(String[] args) {
        // Crear una instancia del menú y mostrarlo
        MenuEjercicio5 menu = new MenuEjercicio5();
        menu.mostrarMenu();
    }
}

class Categoria {
    String nombreCategoria;

    // Constructor por defecto
    public Categoria() {}

    // Constructor que inicializa con el nombre de la categoría
    public Categoria(String nombreCategoria) {
        this.nombreCategoria = nombreCategoria;
    }

    // Getter para obtener el nombre de la categoría
    public String getNombreCategoria() {
        return nombreCategoria;
    }

    // Setter para establecer el nombre de la categoría
    public void setNombreCategoria(String nombreCategoria) {
        this.nombreCategoria = nombreCategoria;
    }

    // Sobrescribe el método toString para representar la categoría como una cadena
    @Override
    public String toString() {
        return "Categoria --> " + nombreCategoria;
    }

    // Método para agregar una categoría a la lista de categorías
    public Vector<Categoria> agregarCategoria(Scanner entrada, Vector<Categoria> listaCategorias) {
        while (true) {
            System.out.println("Introduce el nombre de la categoria:");
            this.nombreCategoria = entrada.nextLine();

            // Validar que el nombre de la categoría no esté vacío
            if (this.nombreCategoria.equals("")) {
                System.out.println("El nombre de la categoria no puede quedar en blanco, introducela de nuevo");
            } else {
                if (!listaCategorias.isEmpty()) {
                    boolean repetida = false;
                    // Verificar si la categoría ya existe en la lista
                    for (Categoria categoria : listaCategorias) {
                        if (categoria.getNombreCategoria().equalsIgnoreCase(this.nombreCategoria)) {
                            repetida = true;
                        }
                    }

                    // Si la categoría ya existe, pedir un nuevo nombre
                    if (repetida) {
                        System.out.println("La categoria ya estaba dada de alta, introducela de nuevo");
                    } else {
                        break;
                    }
                } else {
                    break;
                }
            }
        }

        // Crear una nueva categoría y agregarla a la lista
        Categoria categoria = new Categoria(this.nombreCategoria);
        listaCategorias.add(categoria);
        System.out.println("Nueva categoria dada de alta correctamente");

        return listaCategorias;
    }

    // Método para comprobar si la lista de categorías está vacía
    public boolean comprobarListaCategorias(Vector<Categoria> listaCategorias) {
        if (listaCategorias.isEmpty()) {
            System.out.println("La lista de categorias esta vacia");
            return false;
        } else {
            return true;
        }
    }

    // Método para mostrar la lista de categorías
    public void mostrarListaCategorias(Vector<Categoria> listaCategorias) {
        if (!comprobarListaCategorias(listaCategorias)) {
            return;
        } else {
            int index = 1;
            System.out.println("Lista de categorias");
            // Mostrar cada categoría con su índice
            for (Categoria categoria : listaCategorias) {
                System.out.println("(" + index + ")." + categoria.toString());
                index++;
            }
        }
    }

    // Método para obtener el nombre de una categoría a partir de su índice
    public String nombreCategoria(Scanner entrada, Vector<Categoria> listaCategorias) {
        mostrarListaCategorias(listaCategorias);
        int index = 0;
        while (true) {
            try {
                System.out.println("Introduce el indice de la categoria a borrar");
                index = Integer.parseInt(entrada.nextLine());
            } catch (NumberFormatException e) {
                System.out.println("Formato de indice no valido, introducelo de nuevo");
            }

            // Verificar que el índice esté dentro del rango válido
            if (index < 1 || index > listaCategorias.size()) {
                System.out.println("El indice de la categoria tiene que estar comprendido entre 1 y " + listaCategorias.size() + ", introducelo de nuevo");
            } else {
                break;
            }
        }

        String categoria = "";

        // Buscar la categoría por su índice
        for (int i = 0; i < listaCategorias.size(); i++) {
            if (i == index - 1) {
                categoria = listaCategorias.get(i).getNombreCategoria();
            }
        }

        return categoria;
    }

    // Método para eliminar una categoría de la lista
    public Vector<Categoria> eliminarCategoria(Scanner entrada, Vector<Categoria> listaCategorias, String cate) {
        if (!comprobarListaCategorias(listaCategorias)) {
            return listaCategorias;
        } else {
            char respuesta = ' ';

            // Confirmar la eliminación de la categoría
            while (true) {
                System.out.println("¿Estas seguro que quieres borrar la categoria " + cate + " y todos sus productos asociados (s) o (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;
                }
            }

            if (respuesta == 'n') {
                System.out.println("Operacion de borrado de categoria abortada");
            } else {
                // Usar un iterador para eliminar la categoría
                Iterator<Categoria> it = listaCategorias.iterator();
                while (it.hasNext()) {
                    Categoria cat = it.next();
                    if (cat.getNombreCategoria().equalsIgnoreCase(cate)) {
                        it.remove();
                        System.out.println("Categoria borrada correctamente");
                    }
                }
            }

            return listaCategorias;
        }
    }
}

class Productos {
    String nombre;
    double precio;
    int cantidad;
    Categoria categoria;

    // Constructor por defecto
    public Productos() {}

    // Constructor que inicializa el producto con nombre, precio, cantidad y categoría
    public Productos(String nombre, double precio, int cantidad, Categoria categoria) {
        this.nombre = nombre;
        this.precio = precio;
        this.cantidad = cantidad;
        this.categoria = categoria;
    }

    // Getters y setters para los atributos del producto
    public String getNombre() {
        return nombre;
    }

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

    public double getPrecio() {
        return precio;
    }

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

    public int getCantidad() {
        return cantidad;
    }

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

    public Categoria getCategoria() {
        return categoria;
    }

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

    // Sobrescribe el método toString para representar el producto como una cadena
    @Override
    public String toString() {
        return "\nNombre --> " + nombre + "\nP.V.P --> " + String.format("%.2f", precio) + "€\ncantidad --> " + cantidad + categoria.toString();
    }

    // Método para eliminar productos asociados a una categoría
    public Vector<Productos> eliminarProductos(Scanner entrada, Vector<Productos> listaProductos, String categoria) {
        int contadorProductos = 0;
        Iterator<Productos> it = listaProductos.iterator();
        while (it.hasNext()) {
            Productos producto = it.next();
            if (producto.getCategoria().getNombreCategoria().equalsIgnoreCase(categoria)) {
                it.remove();
                contadorProductos++;
            }
        }

        if (contadorProductos == 0) {
            System.out.println("La categoria " + categoria + " no tenia productos asociados");
        } else if (contadorProductos == 1) {
            System.out.println("Eliminado 1 producto de la categoria " + categoria);
        } else {
            System.out.println("Eliminados " + contadorProductos + " productos de la categoria " + categoria);
        }

        return listaProductos;
    }

    // Método para agregar un producto a la lista de productos
    public Vector<Productos> agregarProducto(Scanner entrada, Vector<Productos> listaProductos, Vector<Categoria> listaCategorias) {
        if (listaCategorias.isEmpty()) {
            System.out.println("No puedes agregar productos hasta que des de alta alguna categoria");
            return listaProductos;
        } else {
            // Pedir al usuario el nombre, precio y cantidad del producto
            while (true) {
                System.out.println("Introduce el nombre del producto:");
                this.nombre = entrada.nextLine();

                if (this.nombre.equals("")) {
                    System.out.println("El nombre del producto no puede quedar vacio, introducelo de nuevo");
                } else {
                    break;
                }
            }

            while (true) {
                try {
                    System.out.println("Introduce el P.V.P del producto " + this.nombre);
                    this.precio = Double.parseDouble(entrada.nextLine());

                    if (this.precio < 0.01) {
                        System.out.println("El P.V.P no puede ser inferior a 1 centimo de €, introducelo de nuevo");
                    } else {
                        break;
                    }
                } catch (NumberFormatException e) {
                    System.err.println("Formato de precio invalido, introducelo de nuevo");
                }
            }

            while (true) {
                try {
                    System.out.println("Introduce la cantidad de productos " + this.nombre + " a dar de alta");
                    this.cantidad = Integer.parseInt(entrada.nextLine());

                    if (this.cantidad <= 0) {
                        System.out.println("La cantidad tiene que ser como minimo 1, introducela de nuevo");
                    } else {
                        break;
                    }
                } catch (NumberFormatException e) {
                    System.err.println("Formato de cantidad no valido, introducela de nuevo");
                }
            }

            Categoria categoria = new Categoria();
            // Solicitar al usuario que elija una categoría
            categoria.setNombreCategoria(categoria.nombreCategoria(entrada, listaCategorias));

            // Crear el producto y agregarlo a la lista de productos
            Productos producto = new Productos(this.nombre, this.precio, this.cantidad, categoria);
            listaProductos.add(producto);

            System.out.println("Producto " + this.nombre + " dado de alta correctamente");

            return listaProductos;
        }
    }

    // Método para mostrar la lista de productos
    public void mostrarListaProductos(Vector<Productos> listaProductos) {
        if (listaProductos.isEmpty()) {
            System.out.println("La lista de productos esta vacia");
        } else {
            int index = 1;
            System.out.println("Lista de productos");
            // Mostrar cada producto con su índice
            for (Productos producto : listaProductos) {
                System.out.println("(" + index + ")." + producto.toString());
                index++;
            }
        }
    }

    // Método para comprobar si la lista de productos está vacía
    public boolean comprobarListaProductos(Vector<Productos> listaProductos) {
        if (listaProductos.isEmpty()) {
            System.out.println("La lista de productos esta vacia");
            return false;
        } else {
            return true;
        }
    }

    // Método para calcular el valor total de los productos de una categoría
    public void calcularValorProductosPorCategoria(Vector<Productos> listaProductos, Vector<Categoria> listaCategorias, String categoria) {
        if (!comprobarListaProductos(listaProductos) || listaCategorias.isEmpty()) {
            return;
        } else {
            double valorTotal = 0.0;
            for (Productos producto : listaProductos) {
                if (producto.getCategoria().getNombreCategoria().equalsIgnoreCase(categoria)) {
                    valorTotal += producto.getCantidad() * producto.getPrecio();
                }
            }

            System.out.println("El valor total de los productos de la categoria " + categoria + " es " + String.format("%.2f", valorTotal) + "€");
        }
    }
}

class MenuEjercicio5 {

    // Método para mostrar el menú principal
    public void mostrarMenu() {
        Vector<Categoria> listaCategorias = new Vector<>();
        Vector<Productos> listaProductos = new Vector<>();
        Scanner entrada = new Scanner(System.in);

        Categoria categoria = new Categoria();
        Productos producto = new Productos();

        int opcion = 0;
        // Bucle principal del menú
        while (true) {
            // Mostrar las opciones del menú
            System.out.println("------ MENU PRINCIPAL ------");
            System.out.println("1. Dar de alta una categoria");
            System.out.println("2. Dar de baja una categoria");
            System.out.println("3. Dar de alta un producto");
            System.out.println("4. Mostrar lista de productos");
            System.out.println("5. Mostrar lista de categorias");
            System.out.println("6. Calcular valor total de los productos de una categoria");
            System.out.println("7. Salir");

            // Pedir al usuario que elija una opción
            while (true) {
                try {
                    System.out.println("Introduce una opcion (1-7):");
                    opcion = Integer.parseInt(entrada.nextLine());
                    if (opcion < 1 || opcion > 7) {
                        System.out.println("Opcion no valida, introducela de nuevo");
                    } else {
                        break;
                    }
                } catch (NumberFormatException e) {
                    System.out.println("Formato de opcion no valido, introducela de nuevo");
                }
            }

            // Ejecutar la opción seleccionada
            switch (opcion) {
                case 1 -> listaCategorias = categoria.agregarCategoria(entrada, listaCategorias);
                case 2 -> {
                    String cate = categoria.nombreCategoria(entrada, listaCategorias);
                    listaCategorias = categoria.eliminarCategoria(entrada, listaCategorias, cate);
                    listaProductos = producto.eliminarProductos(entrada, listaProductos, cate);
                }
                case 3 -> listaProductos = producto.agregarProducto(entrada, listaProductos, listaCategorias);
                case 4 -> producto.mostrarListaProductos(listaProductos);
                case 5 -> categoria.mostrarListaCategorias(listaCategorias);
                case 6 -> {
                    String cate = categoria.nombreCategoria(entrada, listaCategorias);
                    producto.calcularValorProductosPorCategoria(listaProductos, listaCategorias, cate);
                }
                case 7 -> {
                    System.out.println("Saliendo del programa...");
                    entrada.close(); // Cerrar el Scanner
                    System.exit(0); // Terminar el programa
                }
                default -> System.out.println("Opcion no valida");
            }
        }
    }
}