Carlos Fernández García

Ejercicio 1

Crea un programa en Java que gestione una lista de estudiantes inscritos en un curso. El programa debe permitir: Agregar un estudiante al curso. El nombre de cada estudiante debe ser único (sin duplicados). Mostrar todos los estudiantes inscritos. Eliminar un estudiante de la lista de inscritos. Comprobar si un estudiante en particular está inscrito en el curso. Salir del programa. Usa un HashSet para almacenar los nombres de los estudiantes, asegurando que no se repitan. Menú de opciones a implementar: Añadir estudiante. Mostrar lista de estudiantes. Eliminar estudiante. Buscar estudiante. Salir.

package hashset;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Scanner;

public class Ejercicio1 {

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

class Estudiante {
    String nombre; // Atributo que almacena el nombre del estudiante
    
    // Constructor vacío
    public Estudiante() {}

    // Constructor que inicializa el nombre
    public Estudiante(String nombre) {
        this.nombre = nombre;
    }

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

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

    // Método toString que devuelve el nombre del estudiante
    @Override
    public String toString() {
        return nombre;
    }

    // Método equals que compara si dos estudiantes son iguales (ignora mayúsculas)
    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null || getClass() != obj.getClass()) {
            return false;
        }
        Estudiante estudiante = (Estudiante) obj;
        return nombre.equalsIgnoreCase(estudiante.nombre);
    }

    // Método hashCode que genera un hash basado en el nombre en minúsculas
    @Override
    public int hashCode() {
        return nombre.toLowerCase().hashCode();
    }

    // Método para agregar un estudiante a la lista
    public HashSet<Estudiante> agregarEstudiante(Scanner entrada, HashSet<Estudiante> listaEstudiantes) {
        // Ciclo para obtener un nombre de estudiante no vacío
        while (true) {
            System.out.println("Introduce el nombre de estudiante:");
            this.nombre = entrada.nextLine();

            // Comprobar si la entrada es válida
            if (this.nombre.equals("")) {
                System.out.println("No se permiten entradas en blanco, introducela de nuevo");
            } else {
                break; // Salir del ciclo si el nombre es válido
            }
        }

        Estudiante estudiante = new Estudiante(this.nombre);
        // Verifica si el estudiante ya está en la lista
        if (!listaEstudiantes.add(estudiante)) {
            System.out.println("El estudiante ya está inscrito en el curso.");
        } else {
            System.out.println("Estudiante agregado correctamente");
        }
        return listaEstudiantes;
    }

    // Método para mostrar la lista de estudiantes
    public void mostrarLista(HashSet<Estudiante> listaEstudiantes) {
        if (listaEstudiantes.isEmpty()) {
            System.out.println("La lista esta vacia");
        } else {
            System.out.println("Lista de estudiantes agregados");
            int index = 1; // Índice para enumerar estudiantes
            for (Estudiante estudiante : listaEstudiantes) {
                System.out.println(index + " --> " + estudiante.toString());
                index++;
            }
        }
    }

    // Método para eliminar un estudiante de la lista
    public HashSet<Estudiante> eliminarEstudiante(Scanner entrada, HashSet<Estudiante> listaEstudiantes) {
        if (listaEstudiantes.isEmpty()) {
            System.out.println("La lista de estudiantes esta vacia");
            return listaEstudiantes;
        } else {
            while (true) {
                System.out.println("Introduce el nombre a eliminar");
                this.nombre = entrada.nextLine();

                if (this.nombre.equals("")) {
                    System.out.println("No se permite buscar entradas vacias, introducela de nuevo");
                } else {
                    break; // Salir del ciclo si el nombre es válido
                }
            }

            boolean encontradoEstudiante = false; // Bandera para verificar si se encontró al estudiante
            Iterator<Estudiante> it = listaEstudiantes.iterator(); // Iterador para recorrer la lista

            // Buscar y eliminar el estudiante si se encuentra
            while (it.hasNext()) {
                Estudiante estudiante = it.next();
                if (estudiante.getNombre().equalsIgnoreCase(this.nombre)) {
                    it.remove(); // Eliminar el estudiante
                    System.out.println("Estudiante eliminado");
                    encontradoEstudiante = true;
                }
            }

            if (!encontradoEstudiante) {
                System.out.println("El estudiante no se encontraba en la lista");
            }
            return listaEstudiantes;
        }
    }

    // Método para buscar un estudiante en la lista
    public void buscarEstudiante(Scanner entrada, HashSet<Estudiante> listaEstudiantes) {
        if (listaEstudiantes.isEmpty()) {
            System.out.println("La lista de estudiantes esta vacia");
            return;
        } else {
            while (true) {
                System.out.println("Introduce el nombre a buscar");
                this.nombre = entrada.nextLine();

                if (this.nombre.equals("")) {
                    System.out.println("No se permite buscar entradas vacias, introducela de nuevo");
                } else {
                    break; // Salir del ciclo si el nombre es válido
                }
            }

            boolean encontradoEstudiante = false; // Bandera para verificar si se encontró al estudiante

            // Buscar el estudiante en la lista
            for (Estudiante estudiante : listaEstudiantes) {
                if (estudiante.getNombre().equalsIgnoreCase(this.nombre)) {
                    System.out.println("Estudiante encontrado");
                    System.out.println("--> " + estudiante.toString());
                    encontradoEstudiante = true;
                }
            }

            if (!encontradoEstudiante) {
                System.out.println("El estudiante no se encontraba en la lista");
            }
        }
    }
}

class MenuEjercicio1 {
    HashSet<Estudiante> listaEstudiantes = new HashSet<Estudiante>(); // Lista de estudiantes
    Estudiante estudiante = new Estudiante(); // Instancia de Estudiante para usar sus métodos
    int menu = 0; // Variable para el menú
    Scanner entrada = new Scanner(System.in); // Scanner para la entrada del usuario

    // Método para mostrar el menú
    public void mostrarMenu() {
        do {
            // Mostrar opciones del menú
            System.out.println("Menu estudiantes");
            System.out.println("1. Añadir estudiante");
            System.out.println("2. Mostrar lista estudiantes");
            System.out.println("3. Eliminar estudiante");
            System.out.println("4. Buscar estudiante");
            System.out.println("5. Salir");
            System.out.println("Escoge opcion:");

            try {
                // Leer la opción elegida por el usuario
                menu = Integer.parseInt(entrada.nextLine());
                gestionarMenu(menu); // Llamar al método que gestiona la opción seleccionada
            } catch (NumberFormatException e) {
                System.err.println("Formato no valido de menu, introducelo de nuevo");
            }
        } while (menu != 5); // Repetir hasta que el usuario elija salir
    }

    // Método para gestionar la opción del menú seleccionada
    public void gestionarMenu(int menu) {
        switch (menu) {
            case 1 -> listaEstudiantes = estudiante.agregarEstudiante(entrada, listaEstudiantes);
            case 2 -> estudiante.mostrarLista(listaEstudiantes);
            case 3 -> listaEstudiantes = estudiante.eliminarEstudiante(entrada, listaEstudiantes);
            case 4 -> estudiante.buscarEstudiante(entrada, listaEstudiantes); // Añadido: Llamada al método de búsqueda
            case 5 -> {
                System.out.println("Saliendo del programa...");
                entrada.close(); // Cerrar el Scanner antes de salir
                break;
            }
            default -> System.out.println("Opcion no contemplada en el menu, introducela de nuevo");
        }
    }
}

Ejercicio 2

Crea un programa en Java que gestione una biblioteca. El programa debe permitir realizar las siguientes operaciones: Agregar un libro a la biblioteca. Cada libro debe tener un título único (sin duplicados). Mostrar todos los libros disponibles en la biblioteca. Eliminar un libro de la biblioteca. Si el libro no está en la lista, mostrar un mensaje correspondiente. Buscar un libro específico en la biblioteca. Si el libro está presente, mostrar su título; de lo contrario, informar que no está disponible. Salir del programa. Usa un HashSet para almacenar los títulos de los libros, asegurando que no se repitan. Menú de opciones a implementar: Agregar libro. Mostrar lista de libros. Eliminar libro. Buscar libro. Salir.

package hashset;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Scanner;

public class Ejercicio2 {

    public static void main(String[] args) {
        MenuEjercicio2 menu = new MenuEjercicio2();
        menu.mostrarMenu(); // Inicializa el menú de la biblioteca y muestra las opciones.
    }
}

class MenuEjercicio2 {

    HashSet<String> listaLibros = new HashSet<String>(); // Conjunto que almacena los títulos de los libros.
    Scanner entrada = new Scanner(System.in); // Escáner para recibir entradas del usuario.
    int menu = 0; // Variable para almacenar la opción del menú seleccionada.

    public void mostrarMenu() {
        do {
            System.out.println("Menu libro");
            System.out.println("1.Añadir libro");
            System.out.println("2.Mostrar todos los libros");
            System.out.println("3.Eliminar libro");
            System.out.println("4.Buscar libro");
            System.out.println("5.Sali del programa");
            System.out.println("Escoge opcion:");

            try {
                menu = Integer.parseInt(entrada.nextLine()); // Lee y convierte la entrada del menú a un número entero.
                gestionarMenu(menu); // Llama al método que gestiona la opción seleccionada.
            } catch (NumberFormatException e) {
                System.err.println("Formato de menu no valido, introducelo de nuevo"); // Manejo de errores para entradas no válidas.
            }
        } while (menu != 5); // Continúa mostrando el menú hasta que se elija salir.
    }

    private void gestionarMenu(int menu) {
        switch (menu) {
            case 1 -> agregarLibro(); // Opción para agregar un libro.
            case 2 -> mostrarLista(); // Opción para mostrar todos los libros.
            case 3 -> eliminarLibro(); // Opción para eliminar un libro.
            case 4 -> buscarLibro(); // Opción para buscar un libro.
            case 5 -> {
                System.out.println("Saliendo del programa"); // Mensaje al salir.
                entrada.close(); // Cierra el escáner para liberar recursos.
                break;
            }
            default -> System.out.println("Opcion no contemplada en el menu, introducela de nuevo"); // Manejo de opciones no válidas.
        }
    }

    private void agregarLibro() {
        String nombreLibro = "";
        while (true) {
            System.out.println("Introduce el nombre del libro:");
            nombreLibro = entrada.nextLine(); // Lee el nombre del libro.

            if (nombreLibro.equals("")) { // Verifica que el nombre no esté vacío.
                System.out.println("El nombre del libro no puede quedar vacio, introducelo de nuevo");
            } else {
                break; // Salir del bucle si el nombre es válido.
            }
        }
        // Intenta agregar el libro al conjunto y verifica si ya existe.
        if (!listaLibros.add(nombreLibro)) {
            System.out.println("El libro ya estaba dado de alta"); // Mensaje si el libro ya existe.
        } else {
            System.out.println("Libro agregado correctamente a la lista"); // Mensaje de confirmación.
        }
    }

    private void mostrarLista() {
        if (listaLibros.isEmpty()) { // Verifica si la lista está vacía.
            System.out.println("La lista de libros esta vacia");
        } else {
            int index = 1; // Contador para mostrar el índice de cada libro.
            System.out.println("Esta es la lista de libros completa");
            for (String libro : listaLibros) {
                System.out.println(index + "." + libro); // Muestra cada libro con su índice.
                index++; // Incrementa el índice.
            }
        }
    }

    private void eliminarLibro() {
        if (listaLibros.isEmpty()) { // Verifica si la lista está vacía.
            System.out.println("La lista de libros esta vacia");
        } else {
            String libroBorrar = "";

            while (true) {
                System.out.println("Introduce el nombre del libro a borrar:");
                libroBorrar = entrada.nextLine(); // Lee el nombre del libro a borrar.

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

            Iterator<String> it = listaLibros.iterator(); // Crea un iterador para recorrer la lista.
            boolean libroEncontrado = false; // Bandera para indicar si se encontró el libro.

            while (it.hasNext()) {
                String nombreLibro = it.next(); // Obtiene el siguiente libro de la lista.
                if (nombreLibro.equalsIgnoreCase(libroBorrar)) { // Compara el nombre sin importar mayúsculas o minúsculas.
                    it.remove(); // Elimina el libro de la lista.
                    System.out.println("Libro borrado de la lista");
                    libroEncontrado = true; // Marca que el libro fue encontrado.
                }
            }

            if (!libroEncontrado) { // Si no se encontró el libro.
                System.out.println("El libro no se encontraba en la lista");
            }
        }
    }

    private void buscarLibro() {
        if (listaLibros.isEmpty()) { // Verifica si la lista está vacía.
            System.out.println("La lista de libros esta vacia");
        } else {
            String libroBuscar = "";

            while (true) {
                System.out.println("Introduce el nombre del libro a buscar:");
                libroBuscar = entrada.nextLine(); // Lee el nombre del libro a buscar.

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

            boolean libroEncontrado = false; // Bandera para indicar si se encontró el libro.

            for (String libro : listaLibros) {
                if (libroBuscar.equalsIgnoreCase(libro)) { // Compara el nombre sin importar mayúsculas o minúsculas.
                    System.out.println("Libro encontrado");
                    System.out.println(libro); // Muestra el libro encontrado.
                    libroEncontrado = true; // Marca que el libro fue encontrado.
                }
            }

            if (!libroEncontrado) { // Si no se encontró el libro.
                System.out.println("El libro no se encontraba en la lista");
            }
        }
    }
}

Ejercicio 3

Crea un programa en Java que gestione un club de miembros. El programa debe permitir realizar las siguientes operaciones: Agregar un miembro al club. Cada miembro debe tener un nombre único (sin duplicados). Mostrar todos los miembros del club. Eliminar un miembro del club. Si el miembro no está en la lista, mostrar un mensaje correspondiente. Buscar un miembro específico en el club. Si el miembro está presente, mostrar su nombre; de lo contrario, informar que no está disponible. Salir del programa. Usa un HashSet para almacenar los nombres de los miembros, asegurando que no se repitan. Menú de opciones a implementar: Agregar miembro. Mostrar lista de miembros. Eliminar miembro. Buscar miembro. Salir.


package hashset;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Scanner;

public class Ejercicio3 {

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

class MenuEjercicio3 {
    // Conjunto para almacenar los nombres de los miembros, asegurando que no haya duplicados
    HashSet<String> listaMiembros = new HashSet<String>();
    // Scanner para la entrada de datos
    Scanner entrada = new Scanner(System.in);
    
    public void mostraMenu() {
        int menu = 0;
        do {
            // Mostrar opciones del menú
            System.out.println("Menu miembros");
            System.out.println("1. Añadir miembros");
            System.out.println("2. Mostrar todos los miembros");
            System.out.println("3. Eliminar un miembro");
            System.out.println("4. Buscar un miembro");
            System.out.println("5. Salir del programa");
            System.out.println("Escoge opcion:");
            
            try {
                // Leer opción seleccionada
                menu = Integer.parseInt(entrada.nextLine());
                gestionarMenu(menu);
            } catch (NumberFormatException e) {
                // Manejo de entrada no válida
                System.err.println("Formato de menu no valido, introducelo de nuevo");
            }
        } while (menu != 5); // Continuar hasta que el usuario elija salir
    }
    
    private void gestionarMenu(int menu) {
        // Gestión de opciones del menú usando un switch
        switch(menu) {
            case 1 -> agregarMiembro();  // Opción para agregar un miembro
            case 2 -> mostrarMiembros();  // Opción para mostrar todos los miembros
            case 3 -> eliminarMiembro();  // Opción para eliminar un miembro
            case 4 -> buscarMiembro();     // Opción para buscar un miembro
            case 5 -> {
                // Opción para salir del programa
                System.out.println("Saliendo del programa...");
                entrada.close();  // Cerrar el scanner al salir
                break;
            }
            default -> System.out.println("Opcion de menu no contemplada, introducela de nuevo"); // Manejo de opciones inválidas
        }
    }
    
    private String nombreMiembro() {
        String nombre = "";
        
        // Bucle para solicitar un nombre hasta que sea válido
        while (true) {
            System.out.println("Introduce el nombre del miembro:");
            nombre = entrada.nextLine();
            
            if (nombre.equals("")) {
                // Mensaje de error si el nombre está vacío
                System.out.println("El nombre no puede quedar en blanco, introducelo de nuevo");
            } else {
                return nombre; // Retornar el nombre válido
            }
        }
    }
    
    private void agregarMiembro() {
        String nombre = nombreMiembro(); // Obtener el nombre del miembro
        
        // Intentar agregar el miembro al conjunto
        if (!listaMiembros.add(nombre)) {
            // Mensaje si el miembro ya existe
            System.out.println("El miembro ya estaba dado de alta, no se agregara de nuevo");
        } else {
            // Mensaje si se agrega correctamente
            System.out.println("Miembro dado de alta correctamente");
        }
    }
    
    private void mostrarMiembros() {
        // Verificar si la lista de miembros está vacía
        if (listaMiembros.isEmpty()) {
            System.out.println("La lista de miembros esta vacia");
        } else {
            int index = 1;
            System.out.println("Lista de miembros completa");
            // Iterar sobre el conjunto y mostrar los miembros
            for (String miembro : listaMiembros) {
                System.out.println(index + "." + miembro); // Mostrar índice y nombre del miembro
                index++;
            }
        }
    }
    
    private void eliminarMiembro() {
        // Verificar si la lista de miembros está vacía
        if (listaMiembros.isEmpty()) {
            System.out.println("La lista de miembros esta vacia");
        } else {
            String nombreEliminar = nombreMiembro(); // Obtener el nombre del miembro a eliminar
            
            Iterator<String> it = listaMiembros.iterator();
            boolean encontradoMiembro = false;
            char respuesta = ' ';
            
            // Buscar el miembro en el conjunto
            while (it.hasNext()) {
                String nombre = it.next();
                if (nombre.equalsIgnoreCase(nombreEliminar)) { // Comparar sin distinguir mayúsculas/minúsculas
                    while (true) {
                        // Confirmar la eliminación del miembro
                        System.out.println("Miembro encontrado, ¿estás seguro que quieres eliminarlo (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; // Salir del bucle si la respuesta es válida
                        }
                    }
                    
                    if (respuesta == 's') {
                        it.remove(); // Eliminar el miembro si se confirma
                        System.out.println("Miembro " + nombreEliminar + " eliminado con exito de la lista");
                    } else {
                        System.out.println("Operación de eliminación abortada");
                    }
                    encontradoMiembro = true; // Indicar que se encontró el miembro
                }
            }
            
            if (!encontradoMiembro) {
                System.out.println("El miembro no se encontraba en la lista"); // Mensaje si no se encontró el miembro
            }
        }
    }
    
    private void buscarMiembro() {
        // Verificar si la lista de miembros está vacía
        if (listaMiembros.isEmpty()) {
            System.out.println("La lista de miembros esta vacia");
        } else {
            String nombreBuscar = nombreMiembro(); // Obtener el nombre del miembro a buscar
            
            // Verificar si el miembro está en el conjunto
            if (listaMiembros.contains(nombreBuscar)) {
                System.out.println("Miembro encontrado: " + nombreBuscar); // Mostrar miembro encontrado
            } else {
                System.out.println("El miembro no se encuentra en la lista"); // Mensaje si no se encuentra el miembro
            }
        }
    }
}

Ejercicio 4

Crea un programa en Java que realice lo siguiente: Generar 10 números aleatorios entre 1 y 10 (inclusive). Los números generados se deben almacenar en un HashSet, asegurando que no se repitan (gracias a las propiedades del HashSet). El bucle debe repetirse 10 veces, pero solo los números que no sean repetidos serán agregados al HashSet. Al finalizar el proceso, el programa debe mostrar los números almacenados en el HashSet. Requisitos: Usa un bucle for para realizar la generación de números aleatorios. Usa la clase Random para generar los números aleatorios. Muestra al final del programa todos los números generados sin repetidos (es decir, el contenido del HashSet).

Ejercicio 5

Crea un programa en Java que permita generar dos conjuntos de números enteros aleatorios y realice las siguientes operaciones con ellos: Generar dos HashSet con 10 números aleatorios cada uno, en el rango de 1 a 20. Mostrar los números de cada conjunto. Calcular la unión de ambos conjuntos (números presentes en al menos uno de los conjuntos). Calcular la intersección de ambos conjuntos (números que estén en ambos conjuntos). Calcular la diferencia entre el primer y el segundo conjunto (números que están en el primer conjunto pero no en el segundo).

package hashset;

import java.util.HashSet;
import java.util.Random;

public class Ejercicio5 {
    public static void main(String[] args) {
        Random rd = new Random();
        HashSet<Integer> listaUno = new HashSet<Integer>(); // Primer conjunto de números
        HashSet<Integer> listaDos = new HashSet<Integer>(); // Segundo conjunto de números
        int num = 0;

        // Generar 10 números aleatorios en el rango de 1 a 20 para cada conjunto
        for (int i = 0; i < 10; i++) {
            num = rd.nextInt(20) + 1; // Generar un número entre 1 y 20
            listaUno.add(num);        // Agregar número al primer conjunto
            num = rd.nextInt(20) + 1; // Generar otro número entre 1 y 20
            listaDos.add(num);        // Agregar número al segundo conjunto
        }

        // Mostrar los números de la lista uno
        System.out.println("Números de la lista uno");
        for (Integer numero : listaUno) {
            System.out.print(numero + " ");
        }
        System.out.println();

        // Mostrar los números de la lista dos
        System.out.println("Números de la lista dos");
        for (Integer numero : listaDos) {
            System.out.print(numero + " ");
        }
        System.out.println();

        // Calcular la unión de ambos conjuntos (números presentes en al menos uno)
        HashSet<Integer> listaUnion = new HashSet<Integer>();
        listaUnion.addAll(listaUno);  // Agregar todos los elementos de listaUno
        listaUnion.addAll(listaDos);  // Agregar todos los elementos de listaDos

        System.out.println("Resultado de la unión");
        for (Integer numero : listaUnion) {
            System.out.print(numero + " ");
        }
        System.out.println();

        // Calcular la intersección de ambos conjuntos (números presentes en ambos)
        HashSet<Integer> listaInterseccion = new HashSet<Integer>();
        for (Integer numero : listaUno) {
            if (listaDos.contains(numero)) {
                listaInterseccion.add(numero); // Agregar solo si está en ambos
            }
        }

        System.out.println("Resultado de la intersección");
        for (Integer numero : listaInterseccion) {
            System.out.print(numero + " ");
        }
        System.out.println();

        // Calcular la diferencia entre el primer y el segundo conjunto (elementos en listaUno pero no en listaDos)
        System.out.println("Números que solo están en el primero");
        for (Integer numero : listaUno) {
            if (!listaDos.contains(numero)) {
                System.out.print(numero + " ");
            }
        }
        System.out.println();
    }
}