Saltar al contenido
CodigoDev

10 Ejercicios resueltos de ArrayList y HashMap en Java

Java Intermedio
Ejercicios resueltos de ArrayList y HashMap en Java
lightbulb Introducción al ejercicio

Aprende a gestionar colecciones de datos dinámicas con estos 10 ejercicios resueltos de ArrayList y HashMap en Java. Mejora tu lógica de programación, organiza la información eficientemente y domina el nivel intermedio con ejemplos prácticos ideales para aplicar en proyectos reales.

menu_book

Aprendizaje teórico

¿Qué es un ArrayList?

Es una estructura de datos dinámica que funciona como un arreglo tradicional, pero puede crecer o encogerse automáticamente. Es ideal cuando necesitas almacenar listas de elementos (como nombres o precios) donde la cantidad total de datos puede cambiar durante la ejecución del programa.

¿Qué es un HashMap?

Es una colección que almacena datos en pares de «clave-valor», similar a un diccionario. En lugar de acceder a los datos mediante posiciones numéricas, usas una clave única. Por ejemplo, puedes buscar el número de teléfono de una persona (valor) usando su DNI o nombre (clave) casi al instante.

¿Cuándo usar cada uno?

Utiliza un ArrayList cuando el orden de los elementos importa y solo necesites guardar una lista simple. Por el contrario, utiliza un HashMap cuando necesites asociar dos datos relacionados para realizar búsquedas muy rápidas sin tener que recorrer toda la lista.

Ejercicio 1: Tu primera lista dinámica

help_outline Problema:

Crea un ArrayList que almacene texto (Strings). Agrega tres colores diferentes a la lista, elimina el segundo color ingresado y muestra en consola los colores que quedaron almacenados.

Pista

Utiliza el método add() para insertar elementos y el método remove() pasándole el índice (recuerda que empiezan en 0) para eliminar.

code Solución explicada:
java 
import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> colores = new ArrayList<>();

        colores.add("Rojo");
        colores.add("Verde");
        colores.add("Azul");

        // Eliminamos "Verde" (índice 1)
        colores.remove(1);

        System.out.println("Colores en la lista: " + colores);
    }
}

terminal Resultado esperado: 

Colores en la lista: [Rojo, Azul]

Ejercicio 2: El primer diccionario con HashMap

help_outline Problema:

Crea un HashMap donde la clave sea el nombre de un país (String) y el valor sea su capital (String). Agrega tres países con sus respectivas capitales y luego imprime únicamente la capital del segundo país usando su nombre.

Pista

Utiliza put(clave, valor) para insertar los datos y get(clave) para recuperar el valor asociado.

code Solución explicada:
java 
import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap<String, String> paises = new HashMap<>();

        paises.put("España", "Madrid");
        paises.put("Argentina", "Buenos Aires");
        paises.put("Japón", "Tokio");

        String capitalBuscada = paises.get("Argentina");
        System.out.println("La capital de Argentina es: " + capitalBuscada);
    }
}

terminal Resultado esperado: 

La capital de Argentina es: Buenos Aires

Ejercicio 3: Multiplicando elementos en un ArrayList

help_outline Problema:

Crea un ArrayList de números enteros y añade los números del 1 al 5. Utiliza un bucle para recorrer la lista e imprimir cada número multiplicado por 2.

Pista

No puedes usar int directamente en estas colecciones; debes usar la clase envolvente Integer. Un bucle «for-each» es ideal para esta tarea.

code Solución explicada:
java 
import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> numeros = new ArrayList<>();

        for (int i = 1; i <= 5; i++) {
            numeros.add(i);
        }

        System.out.println("Números multiplicados por 2:");
        for (Integer numero : numeros) {
            System.out.println(numero * 2);
        }
    }
}

terminal Resultado esperado: 

Números multiplicados por 2:
2
4
6
8
10

Ejercicio 4: Recorriendo claves y valores

help_outline Problema:

Crea un HashMap que asocie el nombre de un empleado (String) con su salario (Double). Agrega tres empleados y utiliza un bucle para imprimir un mensaje con el formato «El empleado [Nombre] gana $[Salario]».

Pista

Puedes iterar sobre un HashMap obteniendo todas sus claves con el método keySet(), y luego usar cada clave para acceder a su valor.

code Solución explicada:
java 
import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap<String, Double> nominas = new HashMap<>();

        nominas.put("Carlos", 2500.50);
        nominas.put("Ana", 3100.00);
        nominas.put("Luis", 2100.75);

        for (String empleado : nominas.keySet()) {
            Double salario = nominas.get(empleado);
            System.out.println("El empleado " + empleado + " gana $" + salario);
        }
    }
}

terminal Resultado esperado: 

El empleado Carlos gana $2500.5
El empleado Ana gana $3100.0
El empleado Luis gana $2100.75

Ejercicio 5: Filtrado de datos con removeIf

help_outline Problema:

Tienes un ArrayList con las edades de un grupo de personas (ej: 15, 22, 17, 30, 12). Filtra la lista para eliminar a todos los menores de edad (menores de 18), dejando solo a los adultos, y muestra la lista final.

Pista

Desde Java 8, el método removeIf() permite eliminar elementos que cumplan una condición específica usando una expresión Lambda sencilla.

code Solución explicada:
java 
import java.util.ArrayList;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        // Inicializamos la lista con valores predefinidos
        ArrayList<Integer> edades = new ArrayList<>(Arrays.asList(15, 22, 17, 30, 12));

        System.out.println("Edades originales: " + edades);

        // Eliminamos aquellos elementos (e) que sean menores a 18
        edades.removeIf(e -> e < 18);

        System.out.println("Edades de adultos: " + edades);
    }
}

terminal Resultado esperado: 

Edades originales: [15, 22, 17, 30, 12]
Edades de adultos: [22, 30]

Ejercicio 6: Actualización segura de un inventario

help_outline Problema:

Crea un HashMap que represente el inventario de una tienda (producto y cantidad). Verifica si existe el producto «Manzanas». Si existe, suma 50 a su cantidad actual; si no existe, agrégalo con una cantidad de 50. Imprime el inventario.

Pista

El método containsKey() verifica si una clave ya está en el mapa, lo cual es perfecto para decidir si debemos actualizar un valor existente o crear uno nuevo.

code Solución explicada:
java 
import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap<String, Integer> inventario = new HashMap<>();
        
        inventario.put("Naranjas", 30);
        inventario.put("Manzanas", 20); // Ya existen 20 manzanas

        String producto = "Manzanas";

        if (inventario.containsKey(producto)) {
            int cantidadActual = inventario.get(producto);
            inventario.put(producto, cantidadActual + 50);
        } else {
            inventario.put(producto, 50);
        }

        System.out.println("Inventario actualizado: " + inventario);
    }
}

terminal Resultado esperado: 

Inventario actualizado: {Naranjas=30, Manzanas=70}

Ejercicio 7: Buscando coincidencias

help_outline Problema:

Crea un ArrayList de nombres, incluyendo algunos repetidos intencionalmente. Escribe un código que cuente y muestre cuántas veces aparece un nombre específico (por ejemplo, «María») en toda la lista.

Pista

Recorre la lista con un bucle y utiliza el método equals() propio de los Strings para comparar el elemento actual con el nombre que estás buscando.

code Solución explicada:
java 
import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> nombres = new ArrayList<>();
        nombres.add("Juan");
        nombres.add("María");
        nombres.add("Pedro");
        nombres.add("María");
        nombres.add("Ana");

        String nombreBuscado = "María";
        int contador = 0;

        for (String nombre : nombres) {
            if (nombre.equals(nombreBuscado)) {
                contador++;
            }
        }

        System.out.println("El nombre " + nombreBuscado + " aparece " + contador + " veces.");
    }
}

terminal Resultado esperado: 

El nombre María aparece 2 veces.

Ejercicio 8: Contador de frecuencias de palabras

help_outline Problema:

Dado un arreglo de palabras simulando un texto (ej. «java», «codigo», «java», «aprender», «codigo»), utiliza un HashMap para contar de manera automática cuántas veces se repite cada palabra. Imprime el resultado.

Pista

Por cada palabra, usa el método getOrDefault(clave, valorPorDefecto). Si la palabra no existe, devolverá 0 (y le sumas 1). Si ya existe, obtendrá su valor actual y también le sumarás 1.

code Solución explicada:
java 
import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        String[] palabras = {"java", "codigo", "java", "aprender", "codigo"};
        HashMap<String, Integer> frecuencias = new HashMap<>();

        for (String palabra : palabras) {
            // Obtiene el conteo actual (o 0 si no existe) y suma 1
            int conteo = frecuencias.getOrDefault(palabra, 0);
            frecuencias.put(palabra, conteo + 1);
        }

        System.out.println("Frecuencia de palabras: ");
        for (String clave : frecuencias.keySet()) {
            System.out.println(clave + ": " + frecuencias.get(clave));
        }
    }
}

terminal Resultado esperado: 

Frecuencia de palabras: 
java: 2
aprender: 1
codigo: 2

Ejercicio 9: Combinando estructuras (Lista de diccionarios)

help_outline Problema:

A veces necesitas una lista de registros. Crea un ArrayList que almacene objetos HashMap. Cada mapa representará a un alumno con las claves «Nombre» y «Grado». Agrega dos alumnos a la lista e imprime toda la estructura.

Pista

El tipo de dato del ArrayList será HashMap. Instancia mapas individuales, llénalos de datos y luego insértalos en tu lista.

code Solución explicada:
java 
import java.util.ArrayList;
import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        // Una lista que contiene mapas
        ArrayList<HashMap<String, String>> estudiantes = new ArrayList<>();

        HashMap<String, String> estudiante1 = new HashMap<>();
        estudiante1.put("Nombre", "Laura");
        estudiante1.put("Grado", "Avanzado");

        HashMap<String, String> estudiante2 = new HashMap<>();
        estudiante2.put("Nombre", "Diego");
        estudiante2.put("Grado", "Intermedio");

        estudiantes.add(estudiante1);
        estudiantes.add(estudiante2);

        System.out.println("Registro de estudiantes: " + estudiantes);
    }
}

terminal Resultado esperado: 

Registro de estudiantes: [{Grado=Avanzado, Nombre=Laura}, {Grado=Intermedio, Nombre=Diego}]

Ejercicio 10: Sistema de acceso VIP

help_outline Problema:

Imagina una base de datos de usuarios (HashMap con ID y Nombre) y una lista de los IDs que tienen pases VIP (ArrayList). Tu tarea es recorrer la lista VIP, buscar los nombres correspondientes en la base de datos y darles la bienvenida.

Pista

El bucle iterará sobre el ArrayList (los VIP), y por cada ID, lo usarás como clave para hacer un get() sobre el HashMap de usuarios generales.

code Solución explicada:
java 
import java.util.ArrayList;
import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        // Simulamos la base de datos completa de usuarios
        HashMap<Integer, String> usuariosDB = new HashMap<>();
        usuariosDB.put(101, "Marta Gómez");
        usuariosDB.put(102, "Roberto Sánchez");
        usuariosDB.put(103, "Lucía Fernández");
        usuariosDB.put(104, "Tomás Ruiz");

        // IDs que compraron acceso VIP
        ArrayList<Integer> pasesVip = new ArrayList<>();
        pasesVip.add(102);
        pasesVip.add(104);

        System.out.println("--- Ingreso VIP ---");
        // Procesamos solo a los que están en la lista VIP
        for (Integer idVip : pasesVip) {
            String nombreVip = usuariosDB.get(idVip);
            System.out.println("Bienvenido/a a la zona exclusiva, " + nombreVip);
        }
    }
}

terminal Resultado esperado: 

--- Ingreso VIP ---
Bienvenido/a a la zona exclusiva, Roberto Sánchez
Bienvenido/a a la zona exclusiva, Tomás Ruiz
help

Preguntas frecuentes

¿Puedo usar tipos primitivos en ArrayList o HashMap?

No puedes usarlos directamente. Debes utilizar sus clases envolventes (Wrappers), como Integer para int, o Double para double. Afortunadamente, Java realiza la conversión automáticamente de fondo, un proceso conocido como autoboxing.

¿Cuándo es mejor usar ArrayList en lugar de un arreglo normal?

Elige ArrayList cuando no sepas de antemano cuántos elementos vas a almacenar, ya que su tamaño es dinámico. Si el tamaño es fijo y buscas máximo rendimiento en memoria, el arreglo tradicional es mejor.

¿Qué ocurre si guardo un dato en un HashMap con una clave que ya existe?

Si utilizas el método put con una clave existente, el HashMap sobrescribirá el valor anterior con el nuevo. Las claves deben ser estrictamente únicas para evitar la pérdida accidental de información.

task_alt

Conclusión

Dominar ArrayList y HashMap es un paso fundamental para cualquier desarrollador Java. Como has visto en estos ejercicios, estas estructuras te permiten manejar datos de forma dinámica, asociar información compleja y optimizar las búsquedas considerablemente. Ahora tienes las herramientas necesarias para reemplazar arreglos rígidos y construir programas mucho más eficientes y adaptables. Te animo a seguir experimentando: combina ambas colecciones y crea pequeños proyectos, como inventarios o sistemas de gestión escolar, para consolidar tu aprendizaje de forma práctica. ¡La constancia te hará experto!

rocket_launch

Sigue aprendiendo

Documentación oficial de Oracle que detalla todos los métodos disponibles para la clase ArrayList.

Guía oficial y especificaciones técnicas para trabajar con la estructura de diccionario HashMap.

Tutorial de Oracle sobre el framework de colecciones para profundizar en otras estructuras dinámicas.

A
Autor del artículo

Alejandro Nes

calendar_today update Actualizado

Desarrollador de Software y creador de contenido educativo

hardware

Herramientas recomendadas para practicar

Java

Java es un lenguaje de programación orientado a objetos, tipado y multiplataforma, respaldado por la JVM. Su principio de «escribe una vez, ejecuta en cualquier lugar» lo hace útil para sistemas empresariales, microservicios en la nube, escritorio y Android.

Sigue practicando

Otros ejercicios prácticos recomendados

Ver todos arrow_forward