CodeGym /Blog Java /Random-FR /Comment ajouter un nouvel élément à un tableau en Java
John Squirrels
Niveau 41
San Francisco

Comment ajouter un nouvel élément à un tableau en Java

Publié dans le groupe Random-FR
Oh, les tableaux Java. Ils font l'objet d'un amour et d'une haine intenses de la part de centaines de développeurs de logiciels débutants. Ajouter des éléments à un tableau déjà initialisé est impossible, disaient-ils… En fait, c'est possible, mais pas dans un sens classique… et ce n'est pas très pratique. Ajouter de nouveaux éléments à un tableau déjà initialisé est une sorte d'astuce. Cependant, ces astuces peuvent être utiles lors d'un entretien... et parfois dans le travail d'un programmeur. Pour vous assurer que vous aimez utiliser le type de données et que vous savez comment le faire efficacement, nous avons écrit un guide sur l'ajout d'un nouvel élément à un tableau Java. En plus de parcourir attentivement la théorie et les exemples de code, assurez-vous de vérifier et de résoudre les problèmes pratiques présentés dans le message. Comment ajouter un nouvel élément à un tableau en Java - 1

Qu'est-ce qu'un tableau en Java

Rappelons ce qu'est un Array et comment le créer en Java. Si vous vous en souvenez, n'hésitez pas à passer au sous-titre suivant "5 façons d'ajouter de nouveaux éléments aux tableaux Java". La documentation Java officielle d'Oracle indique que les tableaux sont une série de valeurs appartenant au même type de données. Un ensemble d'entiers est un exemple parfait de tableau en Java . Toutes les valeurs que vous définissez ont une position spécifique dans le tableau appelée index . Voici les façons de déclarer et d'initialiser des tableaux :
int[] myArray = new int[10];
int[] myArray1 = {1, 0, 3, 17, 5, 6, 7, 8, 9, 10}
Dans le premier cas, nous avons défini un tableau myArray et fait en sorte que Java alloue de l'espace pour un tableau de 10 éléments, dans le second myArray1 , nous y avons immédiatement entré 10 valeurs. Dans les deux cas, l'élément 11 ne peut pas être simplement poussé dans le tableau. Pour effectuer des opérations avec des tableaux, les développeurs manipulent les indices de valeurs qu'un tableau contient. Que devrions nous faire? Jetons un coup d'œil aux façons les plus courantes d'ajouter au tableau.

5 façons d'ajouter de nouveaux éléments aux tableaux Java

Eh bien, voici nos astuces pour que l'immuable semble mutable.
  • Convertir un tableau en liste
  • Créez un nouveau tableau avec une plus grande capacité et ajoutez un nouvel élément au tableau
  • Implémentation de System.arraycopy()
  • Copier des tableaux à l'aide d'Apache Commons
  • Application de la méthode ArrayCopyOf()
Examinons de plus près ces façons d'ajouter un élément à un tableau.

1. Conversion d'un tableau en liste

Comme nous ne pouvons pas ajouter directement un nouvel élément à un tableau, la meilleure chose à faire est de les convertir en listes, d'ajouter de nouveaux éléments et de reconvertir les valeurs en tableaux. La première façon de convertir un tableau en liste est d'utiliser asList() pour créer une nouvelle ArrayList. Une fois la plage de valeurs transformée avec succès, utilisez ListAdd() pour insérer la valeur. Une fois que vous n'avez plus besoin de modifier un tableau, reconvertissez-le au type de données d'origine à l'aide de la méthode toArray() . Avec toutes les méthodes et conversions, cela peut sembler déroutant au premier abord. Jetons un coup d'œil à l'exemple d'utilisation de asList() pour clarifier les choses.
// Code for adding Java arrays to a program
import java.lang.*;
import java.util.*;

class ArrayDemo{

   //Let’s add a new element to an array
   public static Integer[] addX(Integer myArray[], int x)
   {
       int i;
       //turn array into ArrayList using asList() method
       List arrList = new ArrayList( Arrays.asList(myArray));

       // adding a new element to the array
       arrList.add(x);

       // Transforming the ArrayList into an array
       myArray = arrList.toArray(myArray);
       return myArray;
   }
   public static void main(String[] args)
   {

       int i;
       //initial array
       Integer myArray[] = { 0, 1, 2, 45, 7, 5, 17};

       //print the initial array out
       System.out.println("Initial Array: "
                          + Arrays.toString(myArray));

       //element to be added
       int x = 28;

       // call the method to add x in myArray
       myArray = addX(myArray, x);

       // print the updated array out
       System.out.println("Array with " + x + " added: "
                          + Arrays.toString(myArray));
   }
}
La sortie est :
Tableau initial : [0, 1, 2, 45, 7, 5, 17] Tableau avec 28 ajoutés : [0, 1, 2, 45, 7, 5, 17, 28]
Ainsi, dans le programme, nous avons créé avec succès un tableau myArray de 7 valeurs, l'avons rempli et imprimé. Ensuite, nous avons décidé que dix valeurs ne nous suffisaient pas. Eh bien, nous avons converti myArray en ArrayList arrList en utilisant la méthode Arrays.asList . Voici 28, l'élément à ajouter. Nous l'avons ajouté à ArrayList arrList , puis l'avons reconverti en un tableau à l'aide de la méthode toArray() et avons imprimé le nouveau tableau.

2. Créez une nouvelle baie avec une plus grande capacité

L'une des façons les plus courantes d'ajouter plus d'éléments à un tableau consiste à créer un nouveau tableau plus grand à partir de zéro, en mettant les éléments des anciens et en ajoutant de nouveaux éléments. Voici une présentation étape par étape du processus :
  • Créez un nouveau tableau avec la capacité a+n (a — la capacité originale du tableau, n — le nombre d'éléments que vous voulez ajouter).
  • Ajoutez tous les éléments de la plage de données précédente à la nouvelle, ainsi que les nouvelles valeurs.
  • Imprimez le tableau résultant.
Essayez de créer vous-même un tel tableau et comparez votre code à celui de l'exemple ci-dessous :
// Java Program to add an element in an Array

import java.lang.*;
import java.util.*;

class ArrayDemo {

   //Method to add an element x into array myArray
   public static int[] addX(int myArray[], int x) {
       int i;

       // create a new array of a bigger size (+ one element)
       int newArray[] = new int[myArray.length + 1];

       // insert the elements from the old array into the new one
       for (i = 0; i < myArray.length; i++)
           newArray[i] = myArray[i];

       newArray[myArray.length] = x;
       return newArray;
   }

   public static void main(String[] args) {
       int i;

       // initial array of size 10
       int arr[]
               = {0, 1, 2, 45, 7, 5, 17};

       // print the initial array
       System.out.println("Initial Array: " + Arrays.toString(arr));

       // element to be added
       int x = 28;

       // call the addX method to add x in arr
       arr = addX(arr, x);
       // print the updated array
       System.out.println("Array with " + x + " added:" + Arrays.toString(arr));
   }
}
La sortie est :
Tableau initial : [0, 1, 2, 45, 7, 5, 17] Tableau avec 28 ajoutés : [0, 1, 2, 45, 7, 5, 17, 28]
Eh bien, cette façon d'ajouter un nouvel élément dans un tableau est la plus simple.

3. Application de System.arrayCopy()

System.arrayCopy() est une méthode largement utilisée pour allouer un tableau plus grand à la destination d'un tableau source. Un développeur peut spécifier la séquence qu'il souhaite copier dans un nouveau tableau entre parenthèses de la méthode. Pour voir comment la méthode fonctionne et essayer de l'utiliser par vous-même, jetez un œil à et essayez d'exécuter l'exemple ci-dessous :
import java.util.Arrays;

class ArrayDemo {
   private static Integer[] addElement(Integer[] myArray, int newElement) {
//we create a new Object here, an array of bigger capacity
       Integer[] array = new Integer[myArray.length + 1];
       System.arraycopy(myArray, 0, array, 0, myArray.length);
       array[myArray.length] = newElement;
       return array;
   }

   public static void main(String[] args) {

       Integer[] myArray = {20, 21, 3, 4, 5, 88};
       System.out.println("myArray before adding a new element: " + Arrays.toString(myArray));
       myArray = addElement(myArray, 12);
       System.out.println("myArray before adding a new element: " + Arrays.toString(myArray));
   }
}
La sortie est :
myArray avant d'ajouter un nouvel élément : [20, 21, 3, 4, 5, 88] myArray avant d'ajouter un nouvel élément : [20, 21, 3, 4, 5, 88, 12]
Ici, nous avons créé un tableau myArray , l'avons imprimé et ajouté un nouvel élément à l'aide de notre méthode addElement , qui est construite sur System.arrayCopy() .

4. Utiliser Apache Commons pour copier des tableaux

Utilisons une méthode non standard. À savoir, une bibliothèque tierce Apache Commons lang. Il fait partie du projet Apache Commons axé sur tous les aspects des composants Java réutilisables. La connaissance du projet ne sera pas superflue. Le langage Apache Commons a une méthode add() conçue spécifiquement pour permettre l'expansion des tableaux, cela fait gagner beaucoup de temps et d'efforts aux codeurs. Il convient de garder à l'esprit que cette méthode Apache Commons add() est basée sur l'appel de la méthode System.arraycopy() au cas où vous auriez à répondre à un examen délicat ou à une question d'entretien. Pour ajouter les bibliothèques à votre projet, accédez au site Web Apache Commons et téléchargez les bibliothèques. Ensuite, allez dans Fichier → Structure du projet → Bibliothèques > + et sélectionnez les fichiers jar téléchargés.
import org.apache.commons.lang3.ArrayUtils;
import java.util.Arrays;

class ArrayDemo
{
   private static  T[] append(T[] arr, T element) {
       return ArrayUtils.add(arr, element);
   }

   public static void main(String[] args) {

       Integer[] myArray = { 0, 1, 2, 3, 4};
       System.out.println("myArray: " + Arrays.toString(myArray));

       myArray = append(myArray, 5);
       System.out.println("new Array with the number added: " + Arrays.toString(myArray));
   }
}
La sortie est :
myArray : [0, 1, 2, 3, 4] nouveau tableau avec le numéro ajouté : [0, 1, 2, 3, 4, 5]

5. Implémentation de ArrayCopyOf()

ArrayCopyOf() est une autre méthode pour ajouter un nouvel élément à un tableau. Comme Apache Commons lang add(), il appelle en interne System.arraycopy() pour effectuer cette opération. Cependant, la plupart des développeurs préfèrent ArrayCopyOf() car cela leur permet de garder le code concis et lisible. Voici un exemple d'utilisation de ArrayCopyOf() pour ajouter de nouveaux éléments à un tableau :
import java.util.Arrays;
class ArrayDemo {
   private static  X[] addElement(X[] myArray, X element) {
       X[] array = Arrays.copyOf(myArray, myArray.length + 1);
       array[myArray.length] = element;
       return array;
   }
   public static void main(String[] args) {

       Integer[] myArray = {20, 21, 3, 4, 5, 88};
       System.out.println("myArray before adding a new element: " + Arrays.toString(myArray));
       myArray = addElement(myArray, 12);
       System.out.println("myArray before adding a new element: " + Arrays.toString(myArray));
   }
}
La sortie est :
myArray avant d'ajouter un nouvel élément : [20, 21, 3, 4, 5, 88] myArray avant d'ajouter un nouvel élément : [20, 21, 3, 4, 5, 88, 12]

Conclusion

Savoir comment ajouter des éléments à un tableau aide les développeurs à mettre à jour l'ancien code rapidement sans sacrifier sa fonctionnalité et sa lisibilité… Ou juste pour passer l'entretien. Puisqu'il existe différentes façons d'ajouter des éléments aux tableaux Java, n'hésitez pas à choisir la méthode avec laquelle vous êtes à l'aise.
Commentaires
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION