Arreglos Dinámicos

Semestre 02, 2026

Contenido de la sesión

Arreglos: limitaciones y evolución hacia ArrayList.

ArrayList: importación, inicialización y tipos de datos.

Operaciones: agregar, consultar, modificar y eliminar.

POO: ArrayList de objetos y recorridos.

Arreglos de tamaño fijo

Hasta ahora podemos hacer:


String[] nombres = new String[3];

System.out.println(nombres.length);

Resultado

Las posiciones van del índice 0 al 2.

Cada casilla inicia en null hasta que se le asigna un valor.

El tamaño del arreglo es fijo: se decide al crearlo y no cambia.

Cantidad de datos desconocida

Supongamos que desarrollamos un sistema para registrar perros.

Hoy: 3 perros

Mañana: 15 perros

Después: 100 perros


Perro[] perros = new Perro[100];

Problema

Con un arreglo tradicional debemos decidir el tamaño de antemano. Quizá necesitemos más espacio del previsto, o desperdiciemos memoria reservando de más.

Arreglos dinámicos

Definición

Un arreglo dinámico puede cambiar su cantidad de elementos durante la ejecución del programa. En Java utilizamos la clase ArrayList.

Inicio: la lista está vacía [ ].
Agregar Max: [ Max ]
Agregar Luna: [ Max ] [ Luna ]
Agregar Rocky: [ Max ] [ Luna ] [ Rocky ]
No necesitamos indicar previamente cuántos elementos almacenaremos.

Importar e inicializar un ArrayList

1Paquete

ArrayList pertenece a java.util.
import java.util.ArrayList;

2Creación

ArrayList<String> nombres = new ArrayList<>();
La lista nace vacía: [ ]

3Tamaño inicial

nombres.size() devuelve 0.

ArrayList y tipos de datos


ArrayList<String> nombres = new ArrayList<>();

ArrayList<Integer> edades = new ArrayList<>();

ArrayList<Double> notas = new ArrayList<>();

ArrayList<Perro> perros = new ArrayList<>();

Importante

Con tipos primitivos usamos sus Wrapper Classes.

Primitivo	Wrapper
`int`	`Integer`
`double`	`Double`
`boolean`	`Boolean`
`char`	`Character`

Agregar elementos con add()


ArrayList<String> nombres = new ArrayList<>();

nombres.add("Ana");
nombres.add("Luis");
nombres.add("Carlos");

System.out.println(nombres.size());

Cada elemento se agrega al final y recibe el siguiente índice: Ana en 0, Luis en 1, Carlos en 2.

Resultado: 3

Acceder a elementos con get()

Arreglo tradicional	ArrayList
`nombres[0]`	`nombres.get(0)`


System.out.println(nombres.get(1));

Resultado: Luis

El primer elemento está en el índice 0, el segundo en el 1 y el tercero en el 2.

Modificar elementos con set()


arrayList.set(indice, nuevoValor);

nombres.set(1, "Pedro");

Antes: [ Ana ] [ Luis ] [ Carlos ]

Después: [ Ana ] [ Pedro ] [ Carlos ]

Nota

set reemplaza el valor de una posición existente; no agrega elementos nuevos ni cambia el tamaño de la lista.

Eliminar elementos con remove()

Partimos de la lista [ Ana ] [ Pedro ] [ Carlos ].

AEliminar por posición

nombres.remove(1);
La lista queda [ Ana ] [ Carlos ] y los índices se reacomodan: Carlos pasa del 2 al 1.

BEliminar por contenido

nombres.remove("Carlos");
Busca el elemento por su valor y elimina la primera coincidencia.

Métodos importantes de ArrayList

Método	Función
`add()`	Agregar un elemento a la lista
`get()`	Obtener el elemento de una posición
`set()`	Modificar el elemento de una posición
`remove()`	Eliminar por índice o por contenido
`size()`	Cantidad de elementos almacenados
`contains()`	Verificar si un elemento existe
`isEmpty()`	Verificar si la lista está vacía
`clear()`	Eliminar todos los elementos


boolean existe = nombres.contains("Ana"); // true

Recorrer un ArrayList

Ciclo for tradicional


for (int i = 0; i < nombres.size(); i++) {
    System.out.println(nombres.get(i));
}

Ciclo for-each


for (String nombre : nombres) {
    System.out.println(nombre);
}

Diferencia importante

El arreglo usa .length, sin paréntesis, porque es un atributo. El ArrayList usa .size(), con paréntesis, porque es un método.

ArrayList de objetos

Conectando los arreglos dinámicos con la Programación Orientada a Objetos.


ArrayList<Perro> perros = new ArrayList<>();

Perro perro1 = new Perro("Max", 3);
Perro perro2 = new Perro("Luna", 2);

perros.add(perro1);
perros.add(perro2);

// Agregar un objeto anónimo directamente:
perros.add(new Perro("Rocky", 5));

Recorrer objetos en memoria

perros → índice 0: Max

perros → índice 1: Luna

perros → índice 2: Rocky


for (Perro perro : perros) {
    perro.mostrarInformacion();
}


Perro perro = perros.get(0);

// Max
System.out.println(perro.getNombre());

Buscar un objeto


String buscar = "Luna";

for (Perro perro : perros) {
    if (perro.getNombre().equalsIgnoreCase(buscar)) {
        System.out.println("Encontrado");
        perro.mostrarInformacion();
    }
}


String buscar = "Luna";

for (Perro perro : perros) {
    if (perro.getNombre().equalsIgnoreCase(buscar)) {
        System.out.println("Encontrado");
        perro.mostrarInformacion();
    }
}

String buscar = "Luna";

Guardamos en una variable el nombre que queremos encontrar. Así el criterio de búsqueda queda en un solo lugar y es fácil de cambiar.


String buscar = "Luna";

for (Perro perro : perros) {
    if (perro.getNombre().equalsIgnoreCase(buscar)) {
        System.out.println("Encontrado");
        perro.mostrarInformacion();
    }
}

for (Perro perro : perros)

El ciclo for-each recorre la lista completa y en cada vuelta la variable perro apunta a uno de los objetos almacenados.


String buscar = "Luna";

for (Perro perro : perros) {
    if (perro.getNombre().equalsIgnoreCase(buscar)) {
        System.out.println("Encontrado");
        perro.mostrarInformacion();
    }
}

perro.getNombre()
    .equalsIgnoreCase(buscar)

Pedimos el nombre al objeto con su getter y lo comparamos con el criterio. equalsIgnoreCase ignora mayúsculas y minúsculas, así que luna y Luna coinciden.


String buscar = "Luna";

for (Perro perro : perros) {
    if (perro.getNombre().equalsIgnoreCase(buscar)) {
        System.out.println("Encontrado");
        perro.mostrarInformacion();
    }
}

System.out.println("Encontrado");
perro.mostrarInformacion();

Cuando hay coincidencia avisamos al usuario y pedimos al propio objeto que muestre sus datos. Aquí combinamos ArrayList, objetos con getters, comparación de String y el ciclo for-each.

Resumen

Arreglo tradicional: new Perro[5]; con tamaño fijo.

Arreglo dinámico: new ArrayList<>(); puede crecer y reducirse.

Operaciones: add, get, set, remove y size.

ArrayList de objetos recorrido con for-each y getters.

El arreglo usa .length y el ArrayList usa .size().

Pedir un índice inexistente provoca un error: lo controlaremos en la lección de excepciones.

Meme: ArrayLists sobre arrays, y arrays sobre variables sueltas