Comment ajouter un élément à un tableau Java

Les tableaux Java ont une longueur fixe et ne possèdent pas de méthode push() intégrée. Pour ajouter un élément, choisissez une collection en fonction de l’emplacement souhaité : une pile l’ajoute au sommet, LinkedList.push() l’insère au début et ArrayList.add() l’ajoute à la fin d’une liste redimensionnable. Si vous devez conserver un tableau, copiez ses éléments dans un nouveau tableau plus long et utilisez le tableau renvoyé.

Les cinq exemples Java ci-dessous ont été exécutés avec succès dans l’environnement fourni, chacun avec un code de sortie égal à 0.

Utiliser Stack.push() pour un comportement LIFO

Stack.push() ajoute un élément au sommet d’une pile LIFO (« dernier entré, premier sorti »). L’élément ajouté le plus récemment est donc le premier renvoyé par pop(). L’exemple ajoute trois chaînes, puis affiche et retire l’élément au sommet.

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]

Choisissez cette API lorsque les éléments ajoutés en dernier doivent être traités avant les précédents, par exemple pour suivre des actions à annuler ou des tâches en attente. La pile affichée contient les éléments restants après que pop() a retiré celui du sommet. Si vous souhaitez simplement conserver les valeurs dans leur ordre d’origine, une pile ajoute un comportement inutile ; utilisez plutôt une liste qui ajoute les éléments à la fin.

Utiliser LinkedList.push() pour insérer au début

LinkedList.push() insère un élément au début, et non à la fin. Chaque appel successif place le nouvel élément en première position : l’ordre de la liste est donc l’inverse de celui des appels.

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]

Cette opération insère elle aussi au début : lors de l’affichage de la liste, la valeur la plus récente apparaît en premier. Utilisez-la lorsque cet ordre est voulu, par exemple pour conserver une séquence dont l’élément le plus récent doit rester en tête. Pour ajouter un élément à la fin, choisissez plutôt ArrayList.add() ; bien que les deux méthodes ajoutent une valeur à une collection, elles produisent des résultats différents.

Utiliser ArrayList.add() pour ajouter à la fin d’une liste redimensionnable

Utilisez ArrayList.add() pour ajouter des valeurs à une liste qui peut grandir. Chaque appel ajoute la valeur à la fin. Un ArrayList est une collection, et non un tableau Java ; il n’a donc pas la longueur fixe d’un tableau.

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]

C’est le choix de collection le plus proche lorsque « ajouter à un tableau » signifie conserver l’ordre existant et placer une autre valeur après la dernière. La liste peut grandir au fil des ajouts, et add() n’oblige pas l’appelant à allouer puis à réaffecter un tableau plus grand pour chaque valeur. Choisissez un tableau de taille fixe lorsque sa longueur fait partie de la structure des données ou qu’une autre API l’exige ; choisissez une liste lorsque le nombre de valeurs peut varier et que vous voulez les ajouter à la fin.

Ajouter à un tableau Java avec une méthode personnalisée

Une méthode personnalisée push() peut renvoyer un tableau plus long qui contient les éléments d’origine ainsi que la nouvelle valeur. Comme les tableaux Java ne grandissent pas sur place, l’appelant doit affecter le tableau renvoyé à une variable. La copie prend un temps proportionnel au nombre d’éléments déjà présents et nécessite de la mémoire pour le nouveau tableau.

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 référence renvoyée est importante : le tableau d’origine conserve sa longueur, tandis que push() crée et renvoie un tableau distinct. Affecter le résultat permet aux lectures suivantes d’utiliser le tableau plus long ; ignorer la valeur renvoyée laisse l’appelant utiliser le tableau d’origine. Cette approche est utile lorsqu’une signature de méthode ou une bibliothèque exige un tableau. Chaque nouvel ajout recopie les éléments déjà présents ; pour en ajouter plusieurs, une collection redimensionnable est généralement plus simple et vous évite d’écrire vous-même cette logique de copie.

Utiliser ArrayDeque.push() pour une pile

Pour du nouveau code utilisant une pile, ArrayDeque est une deque redimensionnable qui permet d’insérer et de retirer des éléments à ses deux extrémités. Sa méthode push() ajoute un élément au début, et pop() le retire à cette même extrémité, ce qui donne un comportement LIFO. L’itération sur la deque commence par le début.

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]

Pour obtenir un comportement de pile, ArrayDeque.push() offre le même fonctionnement — l’élément ajouté en dernier se trouve au sommet — que Stack.push(), tandis que la deque permet aussi d’effectuer des opérations à l’autre extrémité. Choisissez cette option si vous avez besoin d’une pile sous forme de deque ; utilisez ArrayList.add() si vous voulez une liste ordonnée où les nouveaux éléments sont ajoutés à la fin. Le choix dépend de l’endroit où les valeurs sont insérées et de la façon de les récupérer : les tableaux Java ne possèdent pas de méthode push() intégrée.