Insertar

Visualizando el crecimiento del arreglo

Imagina que tu arreglo tiene una capacidad inicial de 3 posiciones 🧠 y que el contador comienza en 0.

⬜ ⬜ ⬜     contador = 0

Insertamos el primer elemento

Insertamos el número 10. El contador aumenta a 1.

🟩 ⬜ ⬜     contador = 1

🟩 → posición ocupada ⬜ → posición libre

Seguimos insertando…

Agregamos 20 y 30.

Ahora el arreglo está lleno 😬

🟩 🟩 🟩     contador = 3

Redimensionamiento automático

Intentamos insertar 50

El arreglo está lleno, así que se duplica la capacidad 💡

Antes:  🟩 🟩 🟩
Después: 🟩 🟩 🟩 ⬜ ⬜ ⬜

Insertamos el nuevo elemento

Ahora sí, se agrega el nuevo elemento y el contador sube a 4.

🟩 🟩 🟩 🟩 ⬜ ⬜     contador = 4

Resultado final

Nuestro arreglo puede seguir creciendo automáticamente.

Cada vez que se llena, duplica su tamaño 🚀

Capacidad inicial → 3
Primera expansión → 6
Segunda expansión → 12
...

Clase Arreglo

public class Arreglo {

    private int[] items;

    // Nuevo campo: número de elementos realmente insertados
    private int contador;

    public Arreglo(int longitud){
        items = new int[longitud];
        contador = 0; // al inicio, el arreglo está vacío
    }

    public void imprimir() {
        for (int i = 0; i < contador; i++)
            System.out.println(items[i]);
    }

}

Agregando el método insertar

public void insertar(int item) {
    // Si el array está lleno, debemos redimensionarlo
    // agregar este nuevo elemento al final del array actual.
}

Bien, ahora implementemos el método insertar.

Este método debe añadir un nuevo elemento al final del arreglo actual, y si el arreglo está lleno, redimensionarlo.

Índice del nuevo elemento

public void insertar(int item) {
    items[contador] = item; // lo coloca en la posición libre
    contador++;             // y aumenta el contador
}

Para insertar un nuevo elemento, necesitamos un índice válido.

Índice del nuevo elemento

public void insertar(int item) {
    items[contador++] = item; // lo coloca en la posición libre
}

Ese índice es contador, porque apunta a la primera posición libre del arreglo.

Probemos hasta aquí

public class Main {
    public static void main(String[] args) {
        Arreglo numeros = new Arreglo(3);
        numeros.insertar(10);
        numeros.insertar(20);
        numeros.imprimir();
    }
}

Desde la clase principal, podemos probarlo con unos valores sencillos:

👉 Salida esperada:

10
20

Redimensionar el arreglo

public void insertar(int item) {
    if (items.length == contador) {
        // 1️⃣ Crear un nuevo arreglo del doble de tamaño
        int[] newItems = new int[contador * 2];

        // 2️⃣ Copiar los elementos antiguos al nuevo
        for (int i = 0; i < contador; i++)
            newItems[i] = items[i];

        // 3️⃣ Reemplazar la referencia
        items = newItems;
    }

    // 4️⃣ Insertar el nuevo elemento
    items[contador++] = item;
}

Verificación final

public class Main {
    public static void main(String[] args) {
        Arreglo numeros = new Arreglo(3);
        numeros.insertar(10);
        numeros.insertar(20);
        numeros.insertar(30);
        numeros.insertar(50);
        numeros.imprimir();
    }
}

Probemos nuevamente con más elementos:

Salida esperada:

10
20
30
50

Clase Arreglo

public class Arreglo {

    private int[] items;

    // Nuevo campo: número de elementos realmente insertados
    private int contador;

    public Arreglo(int longitud){
        items = new int[longitud];
        contador = 0; // al inicio, el arreglo está vacío
    }


    public void insertar(int item) {
        // Si el array está lleno, debemos redimensionarlo
        if (items.length == contador) {
            int[] newItems = new int[contador * 2];

            for (int i = 0; i < contador; i++)
                newItems[i] = items[i];

            items = newItems;
        }


        // agregar este nuevo elemento al final del array actual.
        items[contador++] = item;


    }

    public void imprimir() {
        for (int i = 0; i < contador; i++)
            System.out.println(items[i]);
    }

}

Ahora nuestro arreglo se comporta como un array dinámico 💡 Crece automáticamente cuando es necesario, exactamente como lo hacen internamente las clases ArrayList en Java.

“Los buenos comentarios explican por qué algo se hace, no qué hace el código.”