← CC2008

Arreglos Dinámicos

Semestre 02, 2026

Arrays en Java

Tipo fijo: todos los elementos del mismo tipo.
Tamaño fijo: se define al crear y no cambia.
Acceso por índice.
Redimensionar implica crear otro arreglo y copiar.

¿Por qué un arreglo dinámico?

  • Escenarios con cantidad variable de elementos.
  • Necesidad de insertar y eliminar con frecuencia.
  • Evitar manejar manualmente copias y tamaños.
  • Solución: ArrayList<E> (en java.util).

ArrayList

Implementa List<E>; es un arreglo dinámico que crece al necesitar espacio.


import java.util.ArrayList;

ArrayList<String> frutas = new ArrayList<>();
frutas.add("Manzana");
frutas.add("Pera");

System.out.println(frutas.get(0)); // Manzana

Operaciones comunes

add(x), add(0, x): insertar
get(i): leer
set(i, x): reemplazar
remove(i), remove(obj): borrar
size(), contains(x), clear()

Iteración


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

for (String it : items) {
    System.out.println(it);
}

items.forEach(System.out::println);

Modificar la lista mientras iteras con for-each puede lanzar ConcurrentModificationException.

Conversiones


String[] arr = {"A", "B", "C"};

// Array -> List (vista de tamaño fijo)
List<String> view = Arrays.asList(arr);

// Array -> ArrayList independiente
ArrayList<String> l = new ArrayList<>(Arrays.asList(arr));

// List -> Array
String[] copia = l.toArray(new String[0]);

ArrayList con objetos propios


ArrayList<Persona> personas = new ArrayList<>();
personas.add(new Persona("Ana"));
personas.add(new Persona("Luis"));

System.out.println(personas);

Arreglo dinámico propio


class DynamicIntArray {
    private int[] data = new int[4];
    private int size = 0;

    public void add(int v) {
        if (size == data.length) {
            data = Arrays.copyOf(data, data.length * 2);
        }
        data[size++] = v;
    }

    public int get(int i) { return data[i]; }
    public int size() { return size; }
}