Come aggiungere un nuovo elemento a un array in Java

Oh, array Java. Sono oggetto di intenso amore e odio da parte di centinaia di sviluppatori di software principianti. Aggiungere elementi a un array già inizializzato è impossibile, dicevano… In realtà è possibile, ma non in senso classico… e non è molto conveniente. L'aggiunta di nuovi elementi a un array già inizializzato è una specie di trucco. Tuttavia, questi trucchi possono tornare utili in un'intervista ... e talvolta nel lavoro di un programmatore. Per assicurarti che ti piaccia usare il tipo di dati e sapere come farlo in modo efficiente, abbiamo scritto una guida sull'aggiunta di un nuovo elemento a un array Java. Oltre a esaminare attentamente la teoria e gli esempi di codice, assicurati di controllare e completare i problemi pratici descritti nel post.

Che cos'è un array in Java

Ricordiamo cos'è un Array e come crearlo in Java. Se lo ricordi, sentiti libero di saltare al sottotitolo successivo "5 modi per aggiungere nuovi elementi agli array Java". La documentazione Java ufficiale di Oracle afferma che gli array sono una serie di valori appartenenti allo stesso tipo di dati. Un insieme di numeri interi è un perfetto esempio di un array in Java . Tutti i valori definiti hanno una posizione specifica all'interno dell'array chiamata index . Ecco i modi per dichiarare e inizializzare gli array:

int[] myArray = new int[10];
int[] myArray1 = {1, 0, 3, 17, 5, 6, 7, 8, 9, 10}

Nel primo caso, abbiamo definito un array myArray e fatto in modo che Java allochi lo spazio per un array di 10 elementi, nel secondo myArray1 , abbiamo immediatamente inserito 10 valori al suo interno. In entrambi i casi, l'elemento 11 non può essere semplicemente inserito nell'array. Per eseguire operazioni con gli array, gli sviluppatori manipolano gli indici dei valori contenuti in un array. Cosa dovremmo fare? Diamo un'occhiata ai modi più comuni per aggiungere all'array.

5 modi per aggiungere nuovi elementi agli array Java

Bene, ecco i nostri trucchi per far sembrare mutevole l'immutabile.

• Converti un array in un elenco
• Crea un nuovo array con una capacità maggiore e aggiungi un nuovo elemento all'array
• Implementazione di System.arraycopy()
• Copia di array utilizzando Apache Commons
• Applicazione del metodo ArrayCopyOf()

Diamo un'occhiata più da vicino a questi modi per aggiungere un elemento a un array.

1. Conversione di un array in un elenco

Dal momento che non possiamo aggiungere direttamente un nuovo elemento a un array, la cosa migliore da fare è convertirli in liste, aggiungere nuovi elementi e riconvertire i valori in array. Il primo modo per convertire un array in un elenco consiste nell'usare asList() per creare un nuovo ArrayList. Una volta che l'intervallo di valori è stato trasformato correttamente, utilizzare ListAdd() per inserire il valore. Una volta che non è più necessario modificare un array, riconvertire al tipo di dati originale con l'aiuto del metodo toArray() . Con tutti i metodi e le conversioni, all'inizio questo può sembrare confuso. Diamo un'occhiata all'esempio dell'utilizzo di asList() per chiarire le cose.

// 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));
   }
}

L'uscita è: Quindi, nel programma abbiamo creato con successo un array myArray di 7 valori, lo abbiamo compilato e stampato. Poi abbiamo deciso che dieci valori non ci bastavano. Bene, abbiamo convertito myArray in un ArrayList arrList utilizzando il metodo Arrays.asList . Ecco 28, l'elemento da aggiungere. Lo abbiamo aggiunto a ArrayList arrList , quindi lo abbiamo riconvertito in un array utilizzando il metodo toArray() e stampato il nuovo array.

2. Creare un nuovo array con una capacità maggiore

Uno dei modi più comuni per aggiungere più elementi a un array è creare da zero un nuovo array più grande, inserendo gli elementi di quelli vecchi e aggiungendo nuovi elementi. Ecco una procedura dettagliata del processo:

• Crea un nuovo array con la capacità a+n (a - la capacità dell'array originale, n - il numero di elementi che vuoi aggiungere).
• Aggiungi tutti gli elementi dell'intervallo di dati precedente a quello nuovo, nonché i nuovi valori.
• Stampa l'array risultante.

Prova a creare un array di questo tipo da solo e confronta il tuo codice con quello nell'esempio seguente:

// 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));
   }
}

L'uscita è: Bene, questo modo per aggiungere un nuovo elemento in un array è il più semplice.

3. Applicazione di System.arrayCopy()

System.arrayCopy() è un metodo ampiamente utilizzato per allocare un array più grande alla destinazione di un array di origine. Uno sviluppatore può specificare la sequenza che desidera copiare in un nuovo array tra parentesi del metodo. Per vedere come funziona il metodo e provare a usarlo per te stesso, dai un'occhiata e prova a eseguire l'esempio seguente:

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));
   }
}

L'uscita è: Qui abbiamo creato un array myArray , lo abbiamo stampato e aggiunto un nuovo elemento usando il nostro metodo addElement , che è basato su System.arrayCopy() .

4. Utilizzo di Apache Commons per copiare gli array

Usiamo un modo non standard. Vale a dire, una libreria di terze parti Apache Commons lang. Fa parte del progetto Apache Commons incentrato su tutti gli aspetti dei componenti Java riutilizzabili. La conoscenza del progetto non sarà superflua. Apache Commons lang ha un metodo add() progettato specificamente per consentire l'espansione di array, fa risparmiare molto tempo e fatica ai programmatori. Vale la pena tenere presente che questo metodo add() di Apache Commons si basa sulla chiamata al metodo System.arraycopy() nel caso in cui sia necessario rispondere a un esame complicato oa una domanda di colloquio. Per aggiungere le librerie al tuo progetto, vai al sito web di Apache Commons e scarica le librerie. Quindi vai su File → Struttura del progetto → Librerie > + e seleziona i file jar scaricati.

import org.apache.commons.lang3.ArrayUtils;
import java.util.Arrays;

class ArrayDemo {
   private static <T> 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));
   }
}

L'uscita è:

5. Implementazione di ArrayCopyOf()

ArrayCopyOf() è un altro metodo per aggiungere un nuovo elemento a un array. Come Apache Commons lang add() chiama internamente System.arraycopy() per eseguire questa operazione. Tuttavia, la maggior parte degli sviluppatori preferisce ArrayCopyOf() poiché consente loro di mantenere il codice conciso e leggibile. Ecco un esempio di utilizzo di ArrayCopyOf() per aggiungere nuovi elementi a un array:

import java.util.Arrays;
class ArrayDemo {
   private static <X> 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));
   }
}

L'uscita è:

Conclusione

Sapere come aggiungere elementi a un array aiuta gli sviluppatori ad aggiornare rapidamente il vecchio codice senza sacrificarne la funzionalità e la leggibilità... O semplicemente per superare l'intervista. Poiché esistono diversi modi per aggiungere elementi agli array Java, sentiti libero di scegliere il metodo con cui ti senti a tuo agio.