Carlos Fernández García

Ejercicio 1

Escribe un programa en Java que cree una lista de cadenas (String) y utilice un iterador para recorrer la lista e imprimir cada elemento en una línea separada.

Ejercicio 2

Desarrolla un programa en Java que cree un conjunto (Set) de números enteros y utilice un iterador para encontrar e imprimir el mayor número en el conjunto.

Ejercicio 3

Escribe un programa en Java que cree un HashMap de tipo que almacene nombres de personas como claves y sus edades como valores. Utiliza un iterador para recorrer el HashMap e imprimir los nombres de las personas mayores de 18 años.

Ejercicio 4

Desarrolla un programa en Java que cree un LinkedList de objetos Empleado, donde cada objeto Empleado tenga atributos como nombre, salario y edad. Utiliza un iterador para calcular y imprimir el promedio de los salarios de los empleados menores de 30 años.

package iterator;

import java.util.Iterator;
import java.util.LinkedList;

public class Ejercicio4 {

	public static void main(String[] args) {
		Empleado emple1=new Empleado("Carlos",1899.99,42);
		Empleado emple2=new Empleado("Rogelio",1500.99,22);
		Empleado emple3=new Empleado("Rogelia",1400.99,25);
		Empleado emple4=new Empleado("Pepito",1300.99,60);
		Empleado emple5=new Empleado("Manolito",2500.99,18);
		Empleado emple6=new Empleado("Manganito",2000.99,27);
		Empleado emple7=new Empleado("Federico",1154.99,36);
		Empleado emple8=new Empleado("Maroto",3500.99,45);
		Empleado emple9=new Empleado("Gertrudis",2365.99,50);
		Empleado emple10=new Empleado("Topacio",1400.99,20);
		
		LinkedList<Empleado> empleados=new LinkedList<Empleado>();
		
		empleados.add(emple1);		
		empleados.add(emple2);
		empleados.add(emple3);
		empleados.add(emple4);
		empleados.add(emple5);
		empleados.add(emple6);
		empleados.add(emple7);
		empleados.add(emple8);
		empleados.add(emple9);
		empleados.add(emple10);
		
		Iterator<Empleado> it=empleados.iterator();
		double suma=0;
		int contador=0;
		
		while(it.hasNext()) {
			Empleado emple=it.next();
			if(emple.getEdad()<30) {
				suma+=emple.getSalario();
				contador++;
			}
		}
		
		System.out.println("El sueldo medio de los empleados menors de 30 años es "+ String.format("%.2f",suma/contador)+"€");
		
		

	}

}
class Empleado{
	private String nombre;
	private double salario;
	private int edad;
	
	public Empleado(String nombre, double salario, int edad) {
		super();
		this.nombre = nombre;
		this.salario = salario;
		this.edad = edad;
	}

	/**
	 * @return the nombre
	 */
	public String getNombre() {
		return nombre;
	}

	/**
	 * @param nombre the nombre to set
	 */
	public void setNombre(String nombre) {
		this.nombre = nombre;
	}

	/**
	 * @return the salario
	 */
	public double getSalario() {
		return salario;
	}

	/**
	 * @param salario the salario to set
	 */
	public void setSalario(double salario) {
		this.salario = salario;
	}

	/**
	 * @return the edad
	 */
	public int getEdad() {
		return edad;
	}

	/**
	 * @param edad the edad to set
	 */
	public void setEdad(int edad) {
		this.edad = edad;
	}
	
}

Ejercicio 5

Escribe un programa en Java que cree un HashSet de nombres de ciudades y utilice un iterador para imprimir todas las ciudades que comienzan con la letra "B".

Ejercicio 6

Desarrolla un programa en Java que solicite al usuario que ingrese una frase y luego utilice un iterador para imprimir cada palabra de la frase en una línea separada, junto con el número de caracteres que tiene cada palabra.

Ejercicio 7

Desarrolla un programa en Java que cree un ArrayList de números enteros y utilice un iterador para calcular la suma de todos los números pares en la lista.

Ejercicio 8

Desarrolla un programa en Java que cree un HashSet de nombres de países y utilice un iterador para encontrar e imprimir el país que contiene la palabra "United" en su nombre.

Ejercicio 9

Escribe un programa en Java que cree un LinkedList de números enteros y utilice un iterador para encontrar e imprimir el segundo número más grande en la lista.

Ejercicio 10

Desarrolla un programa en Java que cree un HashMap de nombres de estudiantes y sus respectivas edades, y utilice un iterador para imprimir cada nombre junto con su edad en una línea separada.

Ejercicio 11

ENUNCIADO: Crear un programa que gestione una lista de productos usando ArrayList y un Iterator. Cada producto será un String con el nombre. En main: - Crear un ArrayList - Añadir los siguientes productos: Pan Leche Huevos Queso Mantequilla Pan (repetido) - Mostrar todos los productos usando un Iterator - Eliminar todos los productos que se llamen "Pan" usando el Iterator (no con remove directo de la lista) - Volver a recorrer la lista con Iterator y mostrar los productos restantes - Contar cuantos productos quedan en la lista usando el Iterator - Comprobar si existe un producto llamado "Queso" recorriendo la lista con Iterator


package iterator;

import java.util.ArrayList;
import java.util.Iterator;

public class Ejercicio11 {

	public static void main(String[] args) {

		// Lista que almacenará los productos
		ArrayList<String> listaProductos = new ArrayList<String>();

		// Añadimos productos (incluyendo repetidos y diferentes mayúsculas/minúsculas)
		listaProductos.add("Pan");
		listaProductos.add("Leche");
		listaProductos.add("Huevos");
		listaProductos.add("Queso");
		listaProductos.add("Mntequilla");
		listaProductos.add("pan");

		// Creamos un iterator para recorrer la lista
		Iterator<String> it = listaProductos.iterator();

		// Mostramos la lista completa inicial
		mostrarLista(it, listaProductos);

		// Eliminamos todos los productos llamados "pan" (sin importar mayúsculas)
		// IMPORTANTE: se usa it.remove() y no lista.remove()
		while (it.hasNext()) {
			String producto = it.next();

			if (producto.toLowerCase().equals("pan")) {
				it.remove(); // eliminación segura durante iteración
				System.out.println("Producto borrado");
			}
		}

		// Reiniciamos el iterator para volver a recorrer la lista modificada
		it = listaProductos.iterator();

		// Mostramos los productos restantes
		mostrarLista(it, listaProductos);

		// Contamos cuántos productos quedan en la lista usando iterator
		int contadorProductos = 0;

		it = listaProductos.iterator();

		while (it.hasNext()) {
			it.next(); // avanzamos
			contadorProductos++;
		}

		System.out.println("En la lista hay " + contadorProductos + " productos");

		// Comprobamos si existe "queso" en la lista
		it = listaProductos.iterator();

		while (it.hasNext()) {
			String producto = it.next();

			if (producto.toLowerCase().equals("queso")) {
				System.out.println("Hay queso en la lista");
			}
		}
	}

	// Método auxiliar para mostrar todos los productos de la lista
	static void mostrarLista(Iterator<String> it, ArrayList<String> listaProductos) {

		// Se crea un iterator nuevo para asegurar que empieza desde el inicio
		it = listaProductos.iterator();

		while (it.hasNext()) {
			String producto = it.next();
			System.out.println(producto);
		}
	}
}

Ejercicio 12

Crea un programa que gestione una lista de números enteros usando ArrayList y Iterator. En main: Crea un ArrayList. Añade los siguientes números: 3, 7, 10, 15, 20, 7, 30, 5, 10 Recorre la lista con un Iterator y muestra todos los números. Elimina todos los números pares usando el Iterator (no se permite usar remove() directo del ArrayList). Vuelve a recorrer la lista con Iterator y muestra los números restantes. Calcula la suma total de los números que quedan usando el Iterator. Comprueba si existe el número 15 en la lista usando el Iterator. Cuenta cuántos números mayores que 10 hay en la lista usando el Iterator. Todo debe hacerse usando Iterator para practicar su uso completo.

package iterator;

import java.util.ArrayList;
import java.util.Iterator;

public class Ejercicio12 {

	public static void main(String[] args) {

		// ===============================
		// CREACIÓN Y CARGA DE DATOS
		// ===============================
		
		// Lista principal de números
		ArrayList<Integer> listaNumeros = new ArrayList<Integer>();

		// Inserción de valores iniciales
		listaNumeros.add(3);
		listaNumeros.add(7);
		listaNumeros.add(10);
		listaNumeros.add(15);
		listaNumeros.add(20);
		listaNumeros.add(7);
		listaNumeros.add(30);
		listaNumeros.add(5);
		listaNumeros.add(10);

		// Mostrar lista inicial
		mostrarLista(listaNumeros);

		// ===============================
		// ELIMINAR NÚMEROS PARES
		// ===============================
		
		// Se usa Iterator para poder eliminar elementos de forma segura
		Iterator<Integer> it = listaNumeros.iterator();
		int contadorEliminados = 0;

		while (it.hasNext()) {
			int numero = it.next();

			// Si el número es par, se elimina usando el propio iterator
			if (numero % 2 == 0) {
				contadorEliminados++;
				it.remove();
			}
		}

		System.out.println("Un total de " + contadorEliminados + " numeros pares han sido eliminados");

		// Mostrar lista tras eliminación
		mostrarLista(listaNumeros);

		// ===============================
		// SUMA TOTAL
		// ===============================
		
		it = listaNumeros.iterator();
		int sumaTotal = 0;

		while (it.hasNext()) {
			int numero = it.next();
			sumaTotal += numero;
		}

		System.out.println("La suma total de los numeros es " + sumaTotal);

		// ===============================
		// COMPROBAR SI EXISTE EL 15
		// ===============================
		
		it = listaNumeros.iterator();
		boolean existeNumero = false;

		while (it.hasNext()) {
			int numero = it.next();
			if (numero == 15) {
				existeNumero = true;
			}
		}

		if (existeNumero) {
			System.out.println("El numero 15 esta en la lista");
		} else {
			System.out.println("El numero 15 no esta en la lista");
		}

		// ===============================
		// CONTAR MAYORES DE 10
		// ===============================
		
		it = listaNumeros.iterator();
		int contadorNumeros = 0;

		while (it.hasNext()) {
			int numero = it.next();
			if (numero > 10) {
				contadorNumeros++;
			}
		}

		System.out.println("Hay un total de " + contadorNumeros + " mayores de 10 en la lista");
	}

	// Método auxiliar para mostrar la lista usando Iterator
	static void mostrarLista(ArrayList<Integer> listaNumeros) {

		Iterator<Integer> it = listaNumeros.iterator();

		System.out.println("Listado de numeros");

		while (it.hasNext()) {
			int numero = it.next();
			System.out.print(numero + " ");
		}

		System.out.println();
	}
}

Ejercicio 13

ENUNCIADO: Crea un programa que gestione una lista de alumnos usando ArrayList y Iterator. Cada alumno será un objeto con: - String nombre - int edad Pasos en main: 1. Crear un ArrayList. 2. Añadir varios alumnos. 3. Mostrar todos los alumnos usando Iterator. 4. Eliminar con Iterator todos los alumnos menores de 18 años. 5. Volver a mostrar la lista. 6. Calcular la edad media. 7. Comprobar si existe un alumno llamado "Pedro". 8. Contar alumnos mayores de 25 años.


package iterator;

import java.util.ArrayList;
import java.util.Iterator;

public class Ejercicio13 {

	public static void main(String[] args) {

		// ==============================
		// CREACIÓN DE LA LISTA
		// ==============================
		ArrayList<Alumno> listaAlumnos = new ArrayList<>();

		// Creación de objetos Alumno
		Alumno alumno1 = new Alumno("Ana", 17);
		Alumno alumno2 = new Alumno("Luis", 20);
		Alumno alumno3 = new Alumno("Marta", 15);
		Alumno alumno4 = new Alumno("Pedro", 22);
		Alumno alumno5 = new Alumno("Laura", 17);
		Alumno alumno6 = new Alumno("David", 30);

		// Añadimos los alumnos al ArrayList
		listaAlumnos.add(alumno1);
		listaAlumnos.add(alumno2);
		listaAlumnos.add(alumno3);
		listaAlumnos.add(alumno4);
		listaAlumnos.add(alumno5);
		listaAlumnos.add(alumno6);

		// ==============================
		// MOSTRAR LISTA INICIAL
		// ==============================
		mostrarLista(listaAlumnos);

		// ==============================
		// ELIMINAR MENORES DE 18
		// ==============================
		Iterator<Alumno> it = listaAlumnos.iterator();
		int contadorEliminados = 0;

		while (it.hasNext()) {
			Alumno alumno = it.next();

			// Eliminación segura usando Iterator
			if (alumno.getEdad() < 18) {
				it.remove();
				contadorEliminados++;
			}
		}

		System.out.println("Se han eliminado " + contadorEliminados + " alumnos menores de edad");

		// ==============================
		// MOSTRAR LISTA TRAS ELIMINAR
		// ==============================
		mostrarLista(listaAlumnos);

		// ==============================
		// CALCULAR EDAD MEDIA
		// ==============================
		it = listaAlumnos.iterator();
		double sumaEdades = 0;

		while (it.hasNext()) {
			sumaEdades += it.next().getEdad();
		}

		double media = sumaEdades / listaAlumnos.size();
		System.out.println("Edad media -> " + String.format("%.2f", media));

		// ==============================
		// COMPROBAR SI EXISTE PEDRO
		// ==============================
		it = listaAlumnos.iterator();
		boolean existePedro = false;

		while (it.hasNext()) {
			Alumno alumno = it.next();
			if (alumno.getNombre().equalsIgnoreCase("Pedro")) {
				existePedro = true;
				break;
			}
		}

		if (existePedro) {
			System.out.println("Existe un alumno llamado Pedro");
		} else {
			System.out.println("No existe Pedro");
		}

		// ==============================
		// CONTAR MAYORES DE 25
		// ==============================
		it = listaAlumnos.iterator();
		int contadorMayores = 0;

		while (it.hasNext()) {
			if (it.next().getEdad() > 25) {
				contadorMayores++;
			}
		}

		System.out.println("Alumnos mayores de 25 -> " + contadorMayores);
	}

	// ======================================
	// MÉTODO PARA MOSTRAR LISTA CON ITERATOR
	// ======================================
	static void mostrarLista(ArrayList<Alumno> listaAlumnos) {

		Iterator<Alumno> it = listaAlumnos.iterator();

		System.out.println("Listado de alumnos:");
		while (it.hasNext()) {
			System.out.println(it.next());
		}
	}
}

// ==============================
// CLASE ALUMNO
// ==============================
class Alumno {

	private String nombre;
	private int edad;

	public Alumno(String nombre, int edad) {
		this.nombre = nombre;
		this.edad = edad;
	}

	public String getNombre() {
		return nombre;
	}

	public int getEdad() {
		return edad;
	}

	@Override
	public String toString() {
		return "Alumno -> " + nombre + " | Edad -> " + edad;
	}
}

Ejercicio 14

ENUNCIADO (Iterator + Map): Crea un programa que gestione un inventario de tienda usando un HashMap y un Iterator. La clave será el nombre del producto El valor será la cantidad en stock En main: - Crear un HashMap. - Añadir los siguientes productos: Pan → 10 Leche → 5 Huevos → 0 Queso → 7 Mantequilla → 0 Café → 12 - Recorrer el mapa usando Iterator sobre entrySet() y mostrar todos los productos con su stock. - Eliminar con Iterator todos los productos que tengan stock 0. - Volver a recorrer el mapa y mostrar el inventario actualizado. - Calcular el total de unidades en stock usando Iterator. - Comprobar si existe el producto "Queso" usando Iterator. - Contar cuántos productos tienen más de 8 unidades en stock usando Iterator. Todo debe hacerse usando Iterator para recorrer el HashMap.


package iterator;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;

public class Ejercicio14 {

    public static void main(String[] args) {

        // Crear el HashMap que contendrá productos y su stock
        HashMap<String,Integer> listaProductos = new HashMap<>();

        // Añadir productos con sus cantidades
        listaProductos.put("Pan", 10);
        listaProductos.put("Leche", 5);
        listaProductos.put("Huevos", 0);
        listaProductos.put("Queso", 7);
        listaProductos.put("Mantequilla", 0);
        listaProductos.put("Cafe", 12);

        // Mostrar todos los productos iniciales
        mostrarLista(listaProductos);

        // Eliminar productos que tengan stock 0 usando Iterator
        Iterator<Map.Entry<String, Integer>> it = listaProductos.entrySet().iterator();
        int contadorBorrados = 0;
        while(it.hasNext()) {
            Entry<String, Integer> producto = it.next();
            if(producto.getValue() == 0) {
                it.remove();
                contadorBorrados++;
            }
        }

        System.out.println("Un total de " + contadorBorrados + " productos no tenian stock y fueron borrados\n");

        // Mostrar inventario actualizado
        mostrarLista(listaProductos);

        // Calcular el stock total usando Iterator
        it = listaProductos.entrySet().iterator();
        int stockTotal = 0;
        while(it.hasNext()) {
            Entry<String, Integer> producto = it.next();
            stockTotal += producto.getValue();
        }
        System.out.println("El stock total es de " + stockTotal + " unidades\n");

        // Comprobar si existe "Queso" usando Iterator
        it = listaProductos.entrySet().iterator();
        boolean existeProducto = false;
        while(it.hasNext()) {
            Entry<String, Integer> producto = it.next();
            if(producto.getKey().equalsIgnoreCase("queso")) {
                existeProducto = true;
                break;
            }
        }

        if(existeProducto) {
            System.out.println("En la lista hay queso\n");
        } else {
            System.out.println("En la lista no hay queso\n");
        }

        // Contar cuántos productos tienen más de 8 unidades usando Iterator
        it = listaProductos.entrySet().iterator();
        int cuentoMayores = 0;
        while(it.hasNext()) {
            Entry<String, Integer> producto = it.next();
            if(producto.getValue() > 8) {
                cuentoMayores++;
            }
        }

        if(cuentoMayores == 0) {
            System.out.println("No hay ningun producto que tenga mas de 8 unidades de stock");
        } else if(cuentoMayores == 1) {
            System.out.println("Hay un producto que tiene mas de 8 unidades de stock");
        } else {
            System.out.println("Hay " + cuentoMayores + " productos que tienen mas de 8 unidades de stock");
        }
    }

    // Metodo para mostrar la lista de productos con su stock usando Iterator
    static void mostrarLista(HashMap<String,Integer> listaProductos) {
        Iterator<Map.Entry<String, Integer>> it = listaProductos.entrySet().iterator();
        System.out.println("Lista de productos:");
        while(it.hasNext()) {
            Entry<String, Integer> producto = it.next();
            System.out.println("Producto -> " + producto.getKey());
            System.out.println("Stock -> " + producto.getValue() + " unidades\n");
        }
    }
}

Ejercicio 15

Crea un programa que gestione una lista de canciones usando LinkedList y ListIterator. En main: Crear una LinkedList. Añadir las siguientes canciones: Thunder Numb Believer Numb Halo VivaLaVida Recorrer la lista hacia adelante usando ListIterator y mostrar todas las canciones. Mientras recorres con el ListIterator, insertar después de cada canción llamada "Numb" una nueva canción llamada "Numb (Remix)". Volver a recorrer la lista y mostrar el resultado final. Ahora recorrer la lista hacia atrás usando el mismo ListIterator y mostrar las canciones en orden inverso. Contar cuántas canciones contienen la letra "a" usando el ListIterator. Comprobar si existe la canción "Halo" usando el ListIterator.

package iterator;

import java.util.LinkedList;
import java.util.ListIterator;

public class Ejercicio15 {

	public static void main(String[] args) {
		
		// Creamos la lista enlazada de canciones
		LinkedList<String> listaCanciones=new LinkedList<String>();
		
		// Añadimos las canciones iniciales
		listaCanciones.add("Thunder");
		listaCanciones.add("Numb");
		listaCanciones.add("Believer");
		listaCanciones.add("Numb");
		listaCanciones.add("Halo");
		listaCanciones.add("Viva la vida");
		
		// Mostramos lista original
		mostrarLista(listaCanciones);
		
		// Recorremos e insertamos "Numb (Remix)" después de cada "Numb"
		mostrarListaAgregar(listaCanciones);
		
		// Mostramos lista tras modificaciones
		mostrarLista(listaCanciones);
		
		// Mostramos la lista en orden inverso
		mostrarListaInversa(listaCanciones);
		
		// Contamos cuántas canciones contienen la letra 'a'
		System.out.println("Hay " + contarCanciones(listaCanciones) + " canciones que contienen la letra 'a'");
		
		// Comprobamos si existe la canción Halo
		System.out.println((buscarCancion(listaCanciones) ? "Si":"No") + " existe la cancion 'Halo' en la lista de musica");

	}

	
	static void mostrarListaAgregar(LinkedList<String> listaCanciones) {
		// Creamos ListIterator para recorrer y modificar la lista
		ListIterator<String> li=listaCanciones.listIterator();
		
		System.out.println("Listado de canciones");
		
		while(li.hasNext()) {
			String cancion=li.next(); // Obtenemos la siguiente canción
			System.out.println(cancion);
			
			// Si la canción es "Numb", insertamos el remix justo después
			if(cancion.toLowerCase().equals("numb")) {
				li.add("Numb (Remix)");
			}
			
		}
	}
	
	static void mostrarLista(LinkedList<String> listaCanciones) {
		// Iterator bidireccional desde el inicio
		ListIterator<String> li=listaCanciones.listIterator();
		
		System.out.println("Listado de canciones");
		
		while(li.hasNext()) {
			// Mostramos cada canción
			System.out.println(li.next());
		}
	}
	
	static void mostrarListaInversa(LinkedList<String> listaCanciones) {
		// Creamos el iterator al final de la lista para recorrer hacia atrás
		ListIterator<String> li=listaCanciones.listIterator(listaCanciones.size());
		
		System.out.println("Listado de canciones a la inversa");
		
		while(li.hasPrevious()) {
			// Recorremos en sentido inverso
			System.out.println(li.previous());
		}
	}
	
	static int contarCanciones(LinkedList<String> listaCanciones) {
		// Iterator para recorrer la lista
		ListIterator<String> li=listaCanciones.listIterator();
		
		int contadorCanciones=0;
		
		while(li.hasNext()) {
			String cancion=li.next();
			
			// Recorremos cada carácter de la canción
			for (char c : cancion.toLowerCase().toCharArray()) {
				
			    // Si encontramos una 'a' contamos la canción una sola vez
			    if (c == 'a') {
			        contadorCanciones++;
			        break;
			    }
			}
		}
		
		return contadorCanciones;
	}
	
	static boolean buscarCancion(LinkedList<String> listaCanciones) {
		// Iterator para recorrer la lista
		ListIterator<String> li=listaCanciones.listIterator();
		
		while(li.hasNext()) {
			String cancion=li.next();
			
			// Si encontramos "Halo" devolvemos true directamente
			if(cancion.equalsIgnoreCase("halo")) {
				return true;
			}
		}
		
		// Si termina el recorrido y no la encontró
		return false;
	}
}

Ejercicio 16

Enunciado: Reordenar una lista de pasos de una receta Crea un programa que gestione los pasos de una receta usando LinkedList y ListIterator. En main: Crear una LinkedList. Añadir los siguientes pasos de una receta (en este orden): Mezclar harina Añadir huevos Batir la mezcla Hornear a 180°C Enfriar Servir Recorrer la lista con ListIterator y mostrar todos los pasos. Reorganizar la receta: Después del paso "Batir la mezcla", inserta "Añadir chocolate". Antes del paso "Hornear a 180°C", inserta "Precalentar horno a 180°C". Volver a recorrer la lista y mostrar la receta reorganizada. Contar cuántos pasos contienen la palabra "mezcla" usando el ListIterator. Comprobar si existe el paso "Servir" usando el ListIterator. Todo debe hacerse utilizando ListIterator para navegar y modificar la lista.


package iterator;

import java.util.LinkedList;
import java.util.ListIterator;

public class Ejercicio16 {

    public static void main(String[] args) {
        // Crear la lista de pasos de la receta
        LinkedList<String> pasosReceta = new LinkedList<String>();

        // Añadir pasos iniciales en orden
        pasosReceta.add("Mezclar Harina");
        pasosReceta.add("Añadir huevos");
        pasosReceta.add("Batir la mezcla");
        pasosReceta.add("Hornear a 180ºC");
        pasosReceta.add("Enfriar");
        pasosReceta.add("Servir");

        // Mostrar la lista inicial de pasos
        mostrarReceta(pasosReceta);

        // Insertar "Añadir chocolate" después de "Batir la mezcla"
        insertarDespues(pasosReceta);

        // Insertar "Precalentar horno a 180°C" antes de "Hornear a 180ºC"
        insertarAntes(pasosReceta);

        // Mostrar la lista reorganizada
        mostrarReceta(pasosReceta);

        // Contar pasos que contienen la palabra "mezcla"
        contarPasos(pasosReceta);

        // Comprobar si existe el paso "Servir"
        System.out.println((existeServir(pasosReceta) ? "Si" : "No") + " existe el paso 'Servir'");
    }

    // Método para mostrar todos los pasos de la receta
    static void mostrarReceta(LinkedList<String> pasosReceta) {
        ListIterator<String> li = pasosReceta.listIterator();

        System.out.println("----- RECETA PASO A PASO -----");
        while (li.hasNext()) {
            System.out.println(li.next());
        }
        System.out.println();
    }

    // Método para insertar un paso después de "Batir la mezcla"
    static void insertarDespues(LinkedList<String> pasosReceta) {
        ListIterator<String> li = pasosReceta.listIterator();
        while (li.hasNext()) {
            if (li.next().equalsIgnoreCase("Batir la mezcla")) {
                li.add("Añadir chocolate"); // Inserta después del paso
            }
        }
    }

    // Método para insertar un paso antes de "Hornear a 180ºC"
    static void insertarAntes(LinkedList<String> pasosReceta) {
        // Recorremos la lista desde el final para usar previous()
        ListIterator<String> li = pasosReceta.listIterator(pasosReceta.size());
        while (li.hasPrevious()) {
            if (li.previous().equalsIgnoreCase("Hornear a 180ºC")) {
                li.add("Precalentar horno a 180°C"); // Inserta antes del paso
            }
        }
    }

    // Método para contar cuántos pasos contienen la palabra "mezcla"
    static void contarPasos(LinkedList<String> pasosReceta) {
        ListIterator<String> li = pasosReceta.listIterator();
        int contadorCadena = 0;

        while (li.hasNext()) {
            if (li.next().toLowerCase().contains("mezcla")) {
                contadorCadena++;
            }
        }

        // Mensaje según el número de coincidencias
        if (contadorCadena == 0) {
            System.out.println("Ningún paso contenía la palabra 'mezcla'");
        } else if (contadorCadena == 1) {
            System.out.println("Un paso contenía la palabra 'mezcla'");
        } else {
            System.out.println(contadorCadena + " pasos contenían la palabra 'mezcla'");
        }
    }

    // Método para comprobar si existe el paso "Servir"
    static boolean existeServir(LinkedList<String> pasosReceta) {
        ListIterator<String> li = pasosReceta.listIterator();

        while (li.hasNext()) {
            if (li.next().equalsIgnoreCase("servir")) {
                return true; // Retorna true si encuentra "Servir"
            }
        }
        return false; // Retorna false si no lo encuentra
    }
}

Ejercicio 17

Enunciado: Reordenar una lista de pasos de una receta Crea un programa que gestione los pasos de una receta usando LinkedList y ListIterator. En main: Crear una LinkedList. Añadir los siguientes pasos de una receta (en este orden): Mezclar harina Añadir huevos Batir la mezcla Hornear a 180°C Enfriar Servir Recorrer la lista con ListIterator y mostrar todos los pasos. Reorganizar la receta: Después del paso "Batir la mezcla", inserta "Añadir chocolate". Antes del paso "Hornear a 180°C", inserta "Precalentar horno a 180°C". Volver a recorrer la lista y mostrar la receta reorganizada. Contar cuántos pasos contienen la palabra "mezcla" usando el ListIterator. Comprobar si existe el paso "Servir" usando el ListIterator. Todo debe hacerse utilizando ListIterator para navegar y modificar la lista.

package iterator;

import java.util.LinkedList;
import java.util.ListIterator;

public class Ejercicio17 {

	public static void main(String[] args) {
		
		// Crear la lista que almacenará el historial de navegación
		LinkedList<String> historiaNavegacion = new LinkedList<String>();
		
		// Cargar la lista con las páginas iniciales
		historiaNavegacion = cargarLista(historiaNavegacion);
		
		// Mostrar el historial completo hacia adelante
		verHistorial(historiaNavegacion);
		
		// Insertar "youtube.com/recomendaciones" después de cada "youtube.com"
		insertarDespues(historiaNavegacion);
		
		// Volver a mostrar el historial actualizado
		verHistorial(historiaNavegacion);
		
		// Mostrar el historial en orden inverso usando ListIterator
		verHistorialInverso(historiaNavegacion);
		
		// Contar cuántas páginas contienen ".com"
		contarPalabras(historiaNavegacion);
		
		// Comprobar si existe "github.com" en la lista
		System.out.println((existePalabra(historiaNavegacion) ? "Si" : "No") + " existe la entrada 'github.com'");
	}

	// Método que carga las páginas iniciales en la lista
	static LinkedList<String> cargarLista(LinkedList<String> historiaNavegacion){
		historiaNavegacion.add("google.com");
		historiaNavegacion.add("youtube.com");
		historiaNavegacion.add("stackoverflow.com");
		historiaNavegacion.add("github.com");
		historiaNavegacion.add("youtube.com");
		historiaNavegacion.add("reddit.com");
		
		return historiaNavegacion;
	}
	
	// Mostrar todas las páginas hacia adelante
	static void verHistorial(LinkedList<String> historiaNavegacion) {
		ListIterator<String> li = historiaNavegacion.listIterator();

		System.out.println("HISTORIAL DE NAVEGACION");
		while(li.hasNext()) {
			System.out.println(li.next()); 
		}
		System.out.println();
	}
	
	// Insertar "youtube.com/recomendaciones" después de cada "youtube.com"
	static void insertarDespues(LinkedList<String> historiaNavegacion) {
		ListIterator<String> li = historiaNavegacion.listIterator();

		while(li.hasNext()) {
			if(li.next().equals("youtube.com")) {
				li.add("youtube.com/recomendaciones");
			}
		}
	}
	
	// Mostrar la lista en orden inverso usando ListIterator
	static void verHistorialInverso(LinkedList<String> historiaNavegacion) {
		ListIterator<String> li = historiaNavegacion.listIterator(historiaNavegacion.size());

		System.out.println("HISTORIAL DE NAVEGACION INVERSO");
		while(li.hasPrevious()) {
			System.out.println(li.previous()); 
		}
		System.out.println();
	}
	
	// Contar cuántas páginas contienen la palabra ".com"
	static void contarPalabras(LinkedList<String> historiaNavegacion) {
		ListIterator<String> li = historiaNavegacion.listIterator();

		int contadorCom = 0;
		while(li.hasNext()) {
			if(li.next().contains(".com")) {
				contadorCom++;
			}
		}
		
		if(contadorCom == 0) {
			System.out.println("Ninguna entrada de la lista contiene la secuencia '.com'");
		}else if(contadorCom == 1) {
			System.out.println("Una entrada de la lista contiene la secuencia '.com'");
		}else {
			System.out.println(contadorCom + " entradas de la lista contienen la secuencia '.com'");
		}
	}
	
	// Comprobar si existe la página "github.com"
	static boolean existePalabra(LinkedList<String> historiaNavegacion) {
		ListIterator<String> li = historiaNavegacion.listIterator();

		while(li.hasNext()) {
			if(li.next().equals("github.com")) {
				return true;
			}
		}
		return false;
	}
}

Ejercicio 18

Enunciado: Gestionar una lista de tareas con prioridad Crea un programa que gestione una lista de tareas usando ArrayList y ListIterator. La clase Tarea tendrá: - String nombre - int prioridad (del 1 al 5, siendo 1 la más alta) Pasos en main: 1. Crear un ArrayList llamado listaTareas. 2. Añadir las siguientes tareas: - "Hacer la compra", prioridad 3 - "Enviar emails", prioridad 1 - "Limpiar la casa", prioridad 4 - "Estudiar Java", prioridad 2 - "Llamar al banco", prioridad 1 3. Recorrer la lista con ListIterator y mostrar todas las tareas. 4. Mientras recorres la lista: - Si la prioridad de la tarea es 1, añadir "(URGENTE)" al nombre de la tarea usando set(). 5. Volver a recorrer la lista y mostrar las tareas actualizadas. 6. Contar cuántas tareas tienen prioridad mayor que 3 usando ListIterator. 7. Comprobar si existe alguna tarea llamada "Estudiar Java" usando ListIterator. Todo debe hacerse usando ListIterator para recorrer y modificar la lista.


package iterator;

import java.util.ArrayList;
import java.util.ListIterator;

public class Ejercicio18 {

	public static void main(String[] args) {
		
		// Crear la lista de tareas
		ArrayList<Tarea> listaTareas=new ArrayList<Tarea>();
		
		// Cargar la lista con las tareas iniciales
		cargarLista(listaTareas);
		
		// Mostrar todas las tareas
		mostrarLista(listaTareas);
		
		// Añadir "(URGENTE)" a las tareas con prioridad 1
		addUrgente(listaTareas);
		
		// Mostrar la lista actualizada con los cambios
		mostrarLista(listaTareas);
		
		// Contar tareas con prioridad mayor a 3
		contarPrioridad(listaTareas);
		
		// Comprobar si existe la tarea "Estudiar Java"
		System.out.println((existeJava(listaTareas) ? "Si" : "No") + " existe la tarea 'Estudiar Java'");

	}

	// Método para cargar la lista con las tareas iniciales
	static ArrayList<Tarea> cargarLista(ArrayList<Tarea> listaTareas){
		
		Tarea tarea1= new Tarea("Hacer la compra",3);
		Tarea tarea2= new Tarea("Enviar emails",1);
		Tarea tarea3= new Tarea("Limpiar la casa",4);
		Tarea tarea4= new Tarea("Estudiar Java",2);
		Tarea tarea5= new Tarea("Llamar al banco",1);
		
		listaTareas.add(tarea1);
		listaTareas.add(tarea2);
		listaTareas.add(tarea3);
		listaTareas.add(tarea4);
		listaTareas.add(tarea5);
		
		return listaTareas;
	}
	
	// Mostrar todas las tareas de la lista
	static void mostrarLista(ArrayList<Tarea> listaTareas) {
		
		ListIterator<Tarea> li=listaTareas.listIterator();
		
		System.out.println("--- LISTA COMPLETA DE TAREAS ---");
		while(li.hasNext()) {
			System.out.println(li.next());
		}
		System.out.println();
	}
	
	// Añadir "(URGENTE)" a las tareas con prioridad 1 usando ListIterator
	static void addUrgente(ArrayList<Tarea> listaTareas) {
		
		ListIterator<Tarea> li=listaTareas.listIterator();
		
		while(li.hasNext()) {
			Tarea tarea=li.next(); 
			if(tarea.getPrioridad()==1) {
				tarea.setTarea(tarea.getTarea() + " (URGENTE)"); 
			}
		}
	}
	
	// Contar tareas con prioridad mayor a 3 y mostrar el resultado
	static void contarPrioridad(ArrayList<Tarea> listaTareas) {
		
		ListIterator<Tarea> li=listaTareas.listIterator();
		
		int contadorPrioridad=0;
		while(li.hasNext()) {
			if(li.next().getPrioridad()>3) {
				contadorPrioridad++;
			}
		}
		
		if(contadorPrioridad==0) {
			System.out.println("Ninguna tarea tiene prioridad superior a 3");
		}else if(contadorPrioridad==1) {
			System.out.println("Una tarea tiene prioridad superior a 3");
		}else {
			System.out.println(contadorPrioridad + " tareas tiene prioridad superior a 3");
		}
	}
	
	// Comprobar si existe la tarea "Estudiar Java"
	static boolean existeJava(ArrayList<Tarea> listaTareas) {
		
		ListIterator<Tarea> li=listaTareas.listIterator();
		
		while(li.hasNext()) {
			if(li.next().getTarea().equalsIgnoreCase("estudiar java")) {
				return true;
			}
		}
		return false;
	}
}

// Clase Tarea con nombre y prioridad
class Tarea{
	
	String tarea;
	int prioridad;
	
	public Tarea(String tarea, int prioridad) {
		this.tarea = tarea;
		this.prioridad = prioridad;
	}

	public String getTarea() {
		return tarea;
	}

	public void setTarea(String tarea) {
		this.tarea = tarea;
	}

	public int getPrioridad() {
		return prioridad;
	}

	public void setPrioridad(int prioridad) {
		this.prioridad = prioridad;
	}

	@Override
	public String toString() {
		return "Tarea ->" + tarea + "\nPrioridad ->" + prioridad;
	}
}

Ejercicio 19

Enunciado: Gestionar un inventario de productos usando ArrayList y ListIterator Crea un programa que gestione un inventario de productos usando ArrayList y ListIterator. La clase Producto tendrá: String nombre double precio int cantidad Pasos en main: Crear un ArrayList llamado inventario. Añadir los siguientes productos: "Queso", precio 4.5, cantidad 7 "Leche", precio 1.2, cantidad 5 "Pan", precio 0.8, cantidad 10 "Huevos", precio 2.5, cantidad 0 "Mantequilla", precio 3.0, cantidad 0 "Café", precio 5.0, cantidad 12 Recorrer la lista con ListIterator y mostrar todos los productos (nombre, precio, cantidad). Mientras recorres la lista: Si la cantidad es 0, eliminar el producto usando remove(). Si el precio es mayor de 4.0, añadir "(Premium)" al nombre usando set(). Volver a recorrer la lista y mostrar el inventario actualizado. Calcular el total en stock (precio * cantidad) de todos los productos restantes usando ListIterator. Contar cuántos productos tienen cantidad superior a 8 usando ListIterator. Comprobar si existe un producto llamado "Leche" usando ListIterator. Todo debe hacerse usando ListIterator para recorrer y modificar la lista.

package iterator;

import java.util.ArrayList;
import java.util.ListIterator;

public class Ejercicio19 {

    public static void main(String[] args) {
        // Crear un ArrayList de Producto
        ArrayList<Producto> inventario = new ArrayList<Producto>();
        
        // Cargar productos en el inventario
        inventario = cargarInventario(inventario);
        
        // Mostrar inventario inicial
        mostrarInventario(inventario);
        
        // Ajustar inventario: eliminar sin stock y marcar premium según precio
        ajusteInventario(inventario);
        
        // Mostrar inventario actualizado
        mostrarInventario(inventario);
        
        // Calcular el valor total del stock
        calcularStock(inventario);
        
        // Contar productos con cantidad > 8
        contarStock(inventario);
        
        // Comprobar si existe "Leche" en el inventario
        System.out.println((comprobarLeche(inventario) ? "Si" : "No") + " hay leche en el inventario");
    }

    // Método para cargar productos iniciales
    static ArrayList<Producto> cargarInventario(ArrayList<Producto> inventario) {
        // Crear productos
        Producto producto1 = new Producto("Queso", 4.5, 7);
        Producto producto2 = new Producto("Leche", 1.2, 5);
        Producto producto3 = new Producto("Pan", 0.8, 10);
        Producto producto4 = new Producto("Huevos", 2.5, 0);
        Producto producto5 = new Producto("Mantequilla", 3.0, 0);
        Producto producto6 = new Producto("Cafe", 5.0, 12);

        // Añadir productos al inventario
        inventario.add(producto1);
        inventario.add(producto2);
        inventario.add(producto3);
        inventario.add(producto4);
        inventario.add(producto5);
        inventario.add(producto6);

        return inventario;
    }

    // Mostrar todos los productos de la lista
    static void mostrarInventario(ArrayList<Producto> inventario) {
        if (inventario.isEmpty()) {
            System.out.println("No hay productos en el inventario");
        } else {
            ListIterator<Producto> li = inventario.listIterator();
            System.out.println("******* INVENTARIADO *******");
            while (li.hasNext()) {
                System.out.println(li.next());
            }
        }
        System.out.println();
    }

    // Ajustar inventario: eliminar productos sin stock y marcar productos premium
    static void ajusteInventario(ArrayList<Producto> inventario) {
        if (inventario.isEmpty()) {
            System.out.println("No hay productos en el inventario");
        } else {
            ListIterator<Producto> li = inventario.listIterator();

            while (li.hasNext()) {
                Producto producto = li.next();
                // Eliminar productos sin stock
                if (producto.getCantidad() == 0) {
                    System.out.println(producto.getNombre() + " sera eliminado del inventario");
                    li.remove();
                } 
                // Marcar productos premium si su precio es mayor de 4.0
                else if (producto.getPrecio() > 4.0) {
                    Producto productoActualizado = new Producto(
                        producto.getNombre() + " (PREMIUM)", 
                        producto.getPrecio(), 
                        producto.getCantidad()
                    );
                    li.set(productoActualizado); // Actualizar elemento usando set()
                    System.out.println("El producto " + producto.getNombre() + " ha sido actualizado a PREMIUM");
                }
            }
        }
        System.out.println();
    }

    // Calcular el total en stock de todos los productos
    static void calcularStock(ArrayList<Producto> inventario) {
        if (inventario.isEmpty()) {
            System.out.println("No hay productos en el inventario");
        } else {
            ListIterator<Producto> li = inventario.listIterator();
            double sumaStock = 0.0;
            while (li.hasNext()) {
                Producto producto = li.next();
                sumaStock += producto.getPrecio() * producto.getCantidad();
            }
            System.out.println("El stock suma -> " + String.format("%.2f€", sumaStock));
        }
        System.out.println();
    }

    // Contar cuántos productos tienen cantidad > 8
    static void contarStock(ArrayList<Producto> inventario) {
        if (inventario.isEmpty()) {
            System.out.println("No hay productos en el inventario");
        } else {
            ListIterator<Producto> li = inventario.listIterator();
            int cuentoProducto = 0;
            while (li.hasNext()) {
                Producto producto = li.next();
                if (producto.getCantidad() > 8) {
                    cuentoProducto++;
                }
            }

            if (cuentoProducto == 0) {
                System.out.println("No hay ningun producto que tenga mas de 8 unidades en stock");
            } else if (cuentoProducto == 1) {
                System.out.println("Hay un producto que tenga mas de 8 unidades en stock");
            } else {
                System.out.println("Hay " + cuentoProducto + " productos que tienen mas de 8 unidades en stock");
            }
        }
        System.out.println();
    }

    // Comprobar si existe "Leche" en el inventario
    static boolean comprobarLeche(ArrayList<Producto> inventario) {
        if (inventario.isEmpty()) {
            System.out.println("No hay productos en el inventario");
            return false;
        } else {
            ListIterator<Producto> li = inventario.listIterator();
            while (li.hasNext()) {
                Producto producto = li.next();
                if (producto.getNombre().equalsIgnoreCase("leche")) {
                    return true;
                }
            }
            return false;
        }
    }

}

// Clase Producto
class Producto {
    private String nombre;
    private double precio;
    private int cantidad;

    public Producto(String nombre, double precio, int cantidad) {
        this.nombre = nombre;
        this.precio = precio;
        this.cantidad = cantidad;
    }

    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; }

    @Override
    public String toString() {
        return "Producto -> " + nombre + "\nP.V.P -> " + String.format("%.2f€", precio) + "\nStock -> " + cantidad + " unidades\n";
    }
}

Ejercicio 20

Crea una clase Empleado con: String nombre double salario En el main: Crea una ArrayList con estos datos: Ana → 1200 Luis → 1800 Marta → 950 Pedro → 2100 Sofia → 990 Usa ListIterator para recorrer la lista y hacer lo siguiente: Si el salario es menor a 1000, súbele el sueldo a 1000 usando set(). Si el salario es mayor a 2000, elimínalo de la lista con remove(). Cuenta cuántos sueldos fueron modificados. Después del recorrido: Muestra la lista final de empleados. Muestra cuántos salarios se modificaron. Calcula el salario total de la lista. EXTRA (obligatorio para cerrar ListIterator bien): Recorre la lista hacia atrás con hasPrevious() y muestra solo los nombres de los empleados.

package iterator;

import java.util.ArrayList;
import java.util.ListIterator;

public class Ejercicio20 {

	public static void main(String[] args) {
		 
		ArrayList<Empleado> listaEmpleados=new ArrayList<Empleado>();
		
		listaEmpleados=agregarEmpleado(listaEmpleados);
		mostrarLista(listaEmpleados);
		actualizarSueldo(listaEmpleados);
		mostrarLista(listaEmpleados);
		salarioTotal(listaEmpleados);
		mostrarListaInversa(listaEmpleados);

	}
	
	static ArrayList<Empleado> agregarEmpleado(ArrayList<Empleado> listaEmpleados){
		
		Empleado empleado1= new Empleado("Ana",1200);
		Empleado empleado2= new Empleado("Luis",1800);
		Empleado empleado3= new Empleado("Marta",950);
		Empleado empleado4= new Empleado("Pedro",2100);
		Empleado empleado5= new Empleado("Sofia",990);
		
		listaEmpleados.add(empleado1);
		listaEmpleados.add(empleado2);
		listaEmpleados.add(empleado3);
		listaEmpleados.add(empleado4);
		listaEmpleados.add(empleado5);
		
		return listaEmpleados;
	}
	
	static void mostrarLista(ArrayList<Empleado> listaEmpleados) {
		
		if(listaEmpleados.isEmpty()) {
			System.out.println("La lista de empleados esta vacia");
		}else {
			
			ListIterator<Empleado> li=listaEmpleados.listIterator();
			
			System.out.println("** LISTADO DE EMPLEADOS **");
			while(li.hasNext()) {
				System.out.println(li.next());
			}
		}
	}
	
	static void actualizarSueldo(ArrayList<Empleado> listaEmpleados) {
		
		if(listaEmpleados.isEmpty()) {
			System.out.println("La lista de empleados esta vacia");
		}else {
			
			ListIterator<Empleado> li=listaEmpleados.listIterator();
			
		
			int contadorUpdate=0,contadorEliminados=0;
			while(li.hasNext()) {
				Empleado empleado=li.next();
				if(empleado.getSalario()<1000) {
					empleado.setSalario(1000);
					contadorUpdate++;
				}
				if(empleado.getSalario()>2000) {
					li.remove();
					contadorEliminados++;
				}
				
				
			}
			
			if(contadorUpdate==0) {
				System.out.println("Ningun empleado fue actualizado de sueldo");
			}else if(contadorUpdate==1) {
				System.out.println("Un empleado fue actualizado de sueldo");
			}else {
				System.out.println(contadorUpdate + " empleados fue actualizado de sueldo");
			}
			
			if(contadorEliminados==0) {
				System.out.println("Ningun empleado fue despedido");
			}else if(contadorEliminados==1) {
				System.out.println("Un empleado fue despedido");
			}else {
				System.out.println(contadorEliminados + " empleados fueron despedidos");
			}
			

		}
	}
	
	static void salarioTotal(ArrayList<Empleado> listaEmpleados) {
		
		if(listaEmpleados.isEmpty()) {
			System.out.println("La empresa no dispone de empleados en este momento");
		}else {
			ListIterator<Empleado> li=listaEmpleados.listIterator();
			
			
			double sumaSueldos=0.0;
			while(li.hasNext()) {
				sumaSueldos+=li.next().getSalario();
			}
			
			System.out.println("El total de los sueldos asciende a " + String.format("%.2f€", sumaSueldos));
		}
	}
	
	static void mostrarListaInversa(ArrayList<Empleado> listaEmpleados) {
		
		if(listaEmpleados.isEmpty()) {
			System.out.println("La lista de empleados esta vacia");
		}else {
			
			ListIterator<Empleado> li=listaEmpleados.listIterator(listaEmpleados.size());
			
			System.out.println("** LISTADO DE EMPLEADOS A lA INVERSA**");
			while(li.hasPrevious()) {
				System.out.println(li.previous().getNombre());
			}
		}
	}

}

class Empleado{
	
	private String nombre;
	private double salario;
	
	public Empleado(String nombre, double salario) {
	
		this.nombre = nombre;
		this.salario = salario;
	}

	public String getNombre() {
		return nombre;
	}

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

	public double getSalario() {
		return salario;
	}

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

	@Override
	public String toString() {
		return "Empleado -> " + nombre + "\nSalario=" + String.format("%.2f€", salario) + "\n";
	}
	
	
	
	
}