Cómo agregar un elemento a un array de Java

Los arrays de Java tienen una longitud fija y no incluyen un método push(). Para añadir un elemento, elige una colección según la posición que deba ocupar: una pila lo coloca en la parte superior, LinkedList.push() lo inserta al principio y ArrayList.add() lo agrega al final de una lista redimensionable. Si necesitas conservar un array, copia sus elementos en otro más largo y usa el array devuelto.

Los cinco ejemplos de Java siguientes se ejecutaron correctamente en el entorno proporcionado; cada uno terminó con el código de salida 0.

Usar Stack.push() para el comportamiento LIFO

Stack.push() añade un elemento a la parte superior de una pila de tipo «último en entrar, primero en salir» (LIFO). Por eso, el elemento añadido más recientemente es el primero que devuelve pop(). El ejemplo añade tres cadenas y luego imprime y elimina el elemento superior.

import java.util.Stack;

public class StackExample {
  public static void main(String[] args) {
    Stack<String> stack = new Stack<>();
    stack.push("Java");
    stack.push("is");
    stack.push("useful");

    System.out.println("Top: " + stack.peek());
    System.out.println("Removed: " + stack.pop());
    System.out.println("Stack: " + stack);
  }
}

Top: useful
Removed: useful
Stack: [Java, is]

Elige esta API cuando debas procesar los valores más recientes antes que los anteriores, por ejemplo, al registrar acciones para deshacer o tareas pendientes. La pila que se muestra contiene los elementos restantes después de que pop() elimina el elemento superior. Si solo necesitas conservar los valores en su orden original, una pila añade un comportamiento innecesario; usa en su lugar una lista que agregue elementos al final.

Usar LinkedList.push() para insertar al principio

LinkedList.push() inserta un elemento al principio, en lugar de agregarlo al final. Cada llamada sucesiva se convierte en el nuevo primer elemento, así que el orden de la lista queda invertido respecto al orden de las llamadas.

import java.util.LinkedList;

public class LinkedListExample {
  public static void main(String[] args) {
    LinkedList<String> values = new LinkedList<>();
    values.push("Java");
    values.push("is");
    values.push("useful");

    System.out.println(values);
  }
}

[useful, is, Java]

Esta operación también inserta al principio, por lo que, al imprimir la lista, el valor más reciente aparece primero. Úsala cuando ese orden sea intencional, por ejemplo, para mantener una secuencia con el elemento más reciente al principio. Si necesitas agregar al final, elige ArrayList.add(); ambas llamadas añaden un elemento a una colección, pero producen resultados distintos.

Usar ArrayList.add() para agregar al final de una lista redimensionable

Usa ArrayList.add() cuando quieras agregar valores al final de una lista que pueda crecer. La llamada coloca cada valor al final. Un ArrayList es una colección, no un array de Java, así que no tiene la longitud fija de un array.

import java.util.ArrayList;

public class ArrayListExample {
  public static void main(String[] args) {
    ArrayList<String> values = new ArrayList<>();
    values.add("Java");
    values.add("is");
    values.add("useful");

    System.out.println(values);
  }
}

[Java, is, useful]

Esta es la opción de colección más cercana cuando con «añadir a un array» quieres decir conservar el orden existente y colocar otro valor después del último. La lista puede crecer a medida que se añaden valores, y add() no obliga a quien llama a asignar y reasignar un array más grande por cada valor. Elige un array de longitud fija cuando su tamaño forme parte de la estructura de los datos o lo exija otra API; elige una lista cuando el número de valores pueda cambiar y quieras agregarlos al final.

Agregar al final de un array de Java con un método personalizado

Un método push() personalizado puede devolver un array más largo que contenga los elementos originales y el nuevo valor. Quien llama debe asignar el array devuelto, porque los arrays de Java no crecen en el mismo lugar. La copia requiere un tiempo proporcional al número de elementos existentes y memoria para el array nuevo.

public class ArrayAppendExample {
  private static String[] push(String[] array, String value) {
    String[] longer = new String[array.length + 1];
    System.arraycopy(array, 0, longer, 0, array.length);
    longer[array.length] = value;
    return longer;
  }

  public static void main(String[] args) {
    String[] values = {"a", "b", "c"};
    values = push(values, "d");
    System.out.println(java.util.Arrays.toString(values));
  }
}

[a, b, c, d]

La referencia devuelta es importante: el array original conserva su longitud, mientras que push() crea y devuelve otro array. Al asignar el resultado, las lecturas posteriores usan el array más largo; si se ignora el valor devuelto, quien llama sigue usando el original. Este enfoque resulta útil cuando una firma de método o una biblioteca exige un array. Cada repetición de la operación copia los elementos que ya existen, así que, para añadir una secuencia de valores, una colección redimensionable suele ser más sencilla y evita tener que escribir esta lógica de copia.

Usar ArrayDeque.push() como pila

Para código nuevo que necesite una pila, ArrayDeque es una deque redimensionable que permite insertar y eliminar elementos por cualquiera de sus extremos. Su método push() añade al principio y pop() elimina desde ese mismo extremo, lo que proporciona un comportamiento LIFO. La iteración por la deque comienza por el principio.

import java.util.ArrayDeque;

public class ArrayDequeExample {
  public static void main(String[] args) {
    ArrayDeque<String> values = new ArrayDeque<>();
    values.push("Java");
    values.push("is");
    values.push("useful");

    System.out.println("Top: " + values.peek());
    System.out.println("Removed: " + values.pop());
    System.out.println("Deque: " + values);
  }
}

Top: useful
Removed: useful
Deque: [is, Java]

Para el comportamiento de pila, ArrayDeque.push() ofrece el mismo modelo en el que el elemento superior se procesa primero que Stack.push(), y además permite operar en el otro extremo de la deque. Elige esta opción cuando necesites una pila y quieras usar una colección deque; usa ArrayList.add() cuando necesites una lista ordenada con los elementos nuevos al final. La elección depende de dónde se colocan los valores y cómo se recuperan, ya que los arrays de Java no tienen una operación push() integrada.