Como adicionar um elemento a um array Java

Os arrays em Java têm tamanho fixo e não possuem um método push() integrado. Para adicionar um item, escolha uma coleção conforme o local em que ele deve ficar: uma pilha o coloca no topo, LinkedList.push() o insere no início e ArrayList.add() o acrescenta ao final de uma lista redimensionável. Se precisar manter um array, copie seus elementos para um novo array mais longo e use o array retornado.

Os cinco exemplos Java abaixo foram executados com sucesso no ambiente de execução fornecido, todos com código de saída 0.

Use Stack.push() para comportamento LIFO

Stack.push() adiciona um elemento ao topo de uma pilha do tipo último a entrar, primeiro a sair (LIFO). Assim, o item inserido mais recentemente é o primeiro retornado por pop(). O exemplo adiciona três strings à pilha e, em seguida, imprime e remove o item do topo.

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]

Escolha esta API quando os valores mais recentes precisarem ser processados antes dos anteriores, por exemplo, ao controlar ações de desfazer ou tarefas pendentes. A pilha exibida contém os elementos restantes depois que pop() remove o item do topo. Se você só precisa manter os valores na ordem original, uma pilha oferece um comportamento desnecessário; use uma lista que acrescente itens ao final.

Use LinkedList.push() para adicionar no início

LinkedList.push() insere um elemento no início, em vez de acrescentá-lo ao final. Cada chamada adiciona um novo primeiro elemento, portanto a ordem da lista fica inversa à ordem das chamadas.

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 também é uma operação de inserção no início, então o valor mais recente aparece primeiro quando a lista é impressa. Use-a quando essa ordem for intencional, por exemplo, para manter o item mais recente no início de uma sequência. Se a tarefa for adicionar ao final, escolha ArrayList.add(); embora ambas as chamadas adicionem um elemento a uma coleção, elas produzem resultados diferentes.

Use ArrayList.add() para acrescentar ao final de uma lista redimensionável

Use ArrayList.add() quando quiser acrescentar valores ao final de uma lista que pode crescer. A chamada adiciona cada valor ao fim. Um ArrayList é uma coleção, não um array Java, portanto não tem o tamanho fixo de um 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 é a opção de coleção mais próxima quando “adicionar a um array” significa manter a ordem existente e colocar outro valor depois do último. A lista pode crescer à medida que valores são adicionados, e add() não exige que o chamador aloque e reassocie um array maior para cada valor. Escolha um array de tamanho fixo quando o tamanho fizer parte do formato dos dados ou for exigido por outra API; escolha uma lista quando a quantidade de valores puder variar e o comportamento desejado for acrescentar ao final.

Acrescente a um array Java com um método personalizado

Um método personalizado push() pode retornar um array maior que contém os elementos originais e o novo valor. O chamador precisa atribuir o array retornado, pois arrays Java não aumentam de tamanho no próprio local. A cópia leva um tempo proporcional à quantidade de elementos existentes e exige memória para o novo array.

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]

A referência retornada é importante: o array original mantém o tamanho inicial, enquanto push() cria e retorna outro array. Atribuir o resultado faz com que as leituras seguintes usem o array maior; ignorar o valor retornado deixa o chamador usando o array original. Essa abordagem é útil quando uma assinatura de método ou uma biblioteca exige um array. Repetir a operação copia novamente os elementos já existentes a cada chamada; por isso, para uma sequência de adições, uma coleção redimensionável costuma ser mais simples e evita que você precise implementar essa lógica de cópia.

Use ArrayDeque.push() para uma pilha

Para código novo que precisa de uma pilha, ArrayDeque é uma deque redimensionável que permite inserir e remover elementos nas duas extremidades. Seu método push() adiciona ao início, e pop() remove da mesma extremidade, produzindo comportamento LIFO. A iteração pela deque começa pelo início.

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 comportamento de pilha, ArrayDeque.push() oferece o mesmo modelo de processar primeiro o item do topo mostrado com Stack.push(), enquanto a deque também permite operações na outra extremidade. Use-a quando precisar de uma pilha e quiser uma coleção deque; use ArrayList.add() quando o resultado necessário for uma lista ordenada com novos itens no final. A escolha depende de onde os valores devem ficar e de como serão recuperados, pois arrays Java não têm uma operação push integrada.