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
package hashset;
import java.util.HashSet;
import java.util.Random;
public class Ejercicio4 {
public static void main(String[] args) {
// Creamos el HashSet para almacenar los números generados sin repetidos
HashSet<Integer> listaNumeros = new HashSet<Integer>();
int numero = 0;
// Creamos una instancia de Random para generar los números aleatorios
Random rd = new Random();
// Bucle for que itera 10 veces para generar los números aleatorios
for(int i = 0; i < 10; i++) {
// Genera un número aleatorio entre 1 y 10
numero = rd.nextInt(10) + 1;
// Intentamos agregar el número al HashSet
if(!listaNumeros.add(numero)) {
// Si el número ya estaba en el HashSet, no se agrega
System.out.println("El número generado es el " + numero + " pero ya está en la lista, no se agregará.");
} else {
// Si el número es nuevo, se agrega correctamente
System.out.println("Número generado " + numero + " agregado correctamente.");
}
}
// Imprimimos la lista completa de números agregados al HashSet
System.out.println("Lista completa de números agregados al HashSet:");
for (Integer num : listaNumeros) {
System.out.print(num + " ");
}
}
}
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();
}
}