So fügen Sie in Java ein neues Element zu einem Array hinzu

Oh, Java-Arrays. Sie sind das Objekt intensiver Liebe und Hass von Hunderten von Software-Neulingen. Das Hinzufügen von Elementen zu einem Array, das bereits initialisiert wurde, sei unmöglich, sagten sie … Tatsächlich sei es möglich, aber nicht im klassischen Sinne … und es sei nicht sehr praktisch. Das Hinzufügen neuer Elemente zu einem bereits initialisierten Array ist eine Art Trick. Diese Tricks können jedoch in einem Vorstellungsgespräch nützlich sein ... und manchmal auch im Job eines Programmierers. Um sicherzustellen, dass Sie Freude an der Verwendung des Datentyps haben und wissen, wie man ihn effizient macht, haben wir eine Anleitung zum Hinzufügen eines neuen Elements zu einem Java-Array geschrieben. Neben dem sorgfältigen Durchgehen der Theorie und der Codebeispiele sollten Sie sich auch die im Beitrag vorgestellten Übungsaufgaben anschauen und lösen.

Was ist ein Array in Java?

Erinnern wir uns daran, was ein Array ist und wie man es in Java erstellt. Wenn Sie sich daran erinnern, können Sie gerne mit der nächsten Unterüberschrift „5 Möglichkeiten zum Hinzufügen neuer Elemente zu Java-Arrays“ fortfahren. In der offiziellen Java-Dokumentation von Oracle heißt es, dass Arrays eine Reihe von Werten sind, die zum gleichen Datentyp gehören. Eine Menge von Ganzzahlen ist ein perfektes Beispiel für ein Array in Java . Alle von Ihnen definierten Werte haben eine bestimmte Position innerhalb des Arrays, die als Index bezeichnet wird . Hier sind die Möglichkeiten, Arrays zu deklarieren und zu initialisieren:

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

Im ersten Fall haben wir ein Array „myArray“ definiert und Java dazu gebracht, Platz für ein Array mit 10 Elementen zuzuweisen, im zweiten Fall „ myArray1“ haben wir sofort 10 Werte eingegeben. In beiden Fällen kann Element 11 nicht einfach in das Array verschoben werden. Um Operationen mit Arrays durchzuführen, manipulieren Entwickler die Indizes der Werte, die ein Array enthält. Was sollen wir machen? Werfen wir einen Blick auf die gängigsten Methoden zum Hinzufügen zu einem Array.

5 Möglichkeiten, neue Elemente zu Java-Arrays hinzuzufügen

Nun, hier sind unsere Tricks, um das Unveränderliche veränderlich erscheinen zu lassen.

• Konvertieren Sie ein Array in eine Liste
• Erstellen Sie ein neues Array mit größerer Kapazität und fügen Sie dem Array ein neues Element hinzu
• Implementieren von System.arraycopy()
• Arrays mit Apache Commons kopieren
• Anwenden der ArrayCopyOf() -Methode

Schauen wir uns diese Möglichkeiten zum Hinzufügen eines Elements zu einem Array genauer an.

1. Konvertieren eines Arrays in eine Liste

Da wir einem Array kein neues Element direkt hinzufügen können, besteht die nächstbeste Möglichkeit darin, sie in Listen umzuwandeln, neue Elemente hinzuzufügen und die Werte wieder in Arrays umzuwandeln. Die erste Möglichkeit, ein Array in eine Liste umzuwandeln, besteht darin, mit asList() eine neue ArrayList zu erstellen. Sobald der Wertebereich erfolgreich transformiert wurde, fügen Sie den Wert mit ListAdd() ein. Sobald Sie ein Array nicht mehr bearbeiten müssen, konvertieren Sie es mit Hilfe der toArray()- Methode wieder in den ursprünglichen Datentyp . Bei all den Methoden und Umrechnungen kann das zunächst verwirrend wirken. Schauen wir uns das Beispiel der Verwendung von asList() zur Klärung an.

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

Die Ausgabe ist: Im Programm haben wir also erfolgreich ein Array myArray mit 7 Werten erstellt, es ausgefüllt und ausgedruckt. Dann haben wir entschieden, dass uns zehn Werte nicht ausreichen. Nun, wir haben myArray mit der Methode Arrays.asList in eine ArrayList arrList konvertiert . Hier ist 28, das hinzuzufügende Element. Wir haben es zur ArrayList arrList hinzugefügt und es dann mithilfe der toArray()- Methode wieder in ein Array konvertiert und das neue Array ausgedruckt.

2. Erstellen Sie ein neues Array mit größerer Kapazität

Eine der gebräuchlichsten Methoden, einem Array weitere Elemente hinzuzufügen, besteht darin, ein neues, größeres Array von Grund auf zu erstellen, die Elemente des alten einzufügen und neue Elemente hinzuzufügen. Hier ist eine Schritt-für-Schritt-Anleitung des Prozesses:

• Erstellen Sie ein neues Array mit der Kapazität a+n (a – die ursprüngliche Array-Kapazität, n – die Anzahl der Elemente, die Sie hinzufügen möchten).
• Fügen Sie alle Elemente des vorherigen Datenbereichs sowie die neuen Werte zum neuen hinzu.
• Drucken Sie das resultierende Array.

Versuchen Sie, selbst ein solches Array zu erstellen, und vergleichen Sie Ihren Code mit dem im folgenden Beispiel:

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

Die Ausgabe ist: Nun, diese Methode zum Hinzufügen eines neuen Elements zu einem Array ist die einfachste.

3. Anwenden von System.arrayCopy()

System.arrayCopy() ist eine weit verbreitete Methode zum Zuweisen eines größeren Arrays am Ziel eines Quellarrays. In den Klammern der Methode kann ein Entwickler die Sequenz angeben, die er in ein neues Array kopieren möchte. Um zu sehen, wie die Methode funktioniert, und um sie selbst auszuprobieren, werfen Sie einen Blick auf das folgende Beispiel und versuchen Sie es auszuführen:

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

Die Ausgabe ist: Hier haben wir ein Array myArray erstellt , es ausgedruckt und mithilfe unserer addElement- Methode, die auf System.arrayCopy() aufbaut, ein neues Element hinzugefügt .

4. Verwenden von Apache Commons zum Kopieren von Arrays

Lassen Sie uns einen nicht standardmäßigen Weg verwenden. Nämlich eine Drittanbieter-Bibliothek, Apache Commons lang. Es ist Teil des Apache Commons-Projekts, das sich auf alle Aspekte wiederverwendbarer Java-Komponenten konzentriert. Kenntnisse über das Projekt werden nicht überflüssig sein. Die Apache Commons-Sprache verfügt über eine Methode add() , die speziell zum Erweitern von Arrays entwickelt wurde und Programmierern viel Zeit und Mühe spart. Beachten Sie, dass diese add()- Methode von Apache Commons auf dem Aufruf der System.arraycopy()- Methode basiert , falls Sie eine knifflige Prüfungs- oder Interviewfrage beantworten müssen. Um die Bibliotheken zu Ihrem Projekt hinzuzufügen, gehen Sie zur Apache Commons- Website und laden Sie die Bibliotheken herunter. Gehen Sie dann zu Datei → Projektstruktur → Bibliotheken > + und wählen Sie die heruntergeladenen JAR-Dateien aus.

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

Die Ausgabe ist:

5. ArrayCopyOf() implementieren

ArrayCopyOf() ist eine weitere Methode zum Hinzufügen eines neuen Elements zu einem Array. Wie Apache Commons lang add() ruft es intern System.arraycopy() auf , um diesen Vorgang auszuführen. Die meisten Entwickler bevorzugen jedoch ArrayCopyOf(), da es ihnen ermöglicht, den Code prägnant und lesbar zu halten. Hier ist ein Beispiel für die Verwendung von ArrayCopyOf() zum Hinzufügen neuer Elemente zu einem 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));
   }
}

Die Ausgabe ist:

Abschluss

Zu wissen, wie man einem Array Elemente hinzufügt, hilft Entwicklern, den alten Code schnell zu aktualisieren, ohne seine Funktionalität und Lesbarkeit zu beeinträchtigen … oder einfach nur, um das Vorstellungsgespräch zu bestehen. Da es verschiedene Möglichkeiten gibt, Elemente zu Java-Arrays hinzuzufügen, können Sie die Methode wählen, mit der Sie vertraut sind.