HOWTO · Java
So fügen Sie ein Element zu einem Java-Array hinzu
Erfahren Sie, warum Java-Arrays keine eingebaute push()-Methode haben und wie Sie Werte mit einem Stack, einer Liste oder einer Array-Kopie hinzufügen.
Auf dieser Seite
Java-Arrays haben eine feste Länge und keine eingebaute push()-Methode. Wählen Sie zum Hinzufügen eines Elements eine Collection danach aus, an welcher Stelle es eingefügt werden soll: Ein Stack legt es oben ab, LinkedList.push() fügt es am Anfang ein und ArrayList.add() hängt es an eine dynamisch wachsende Liste an. Wenn Sie ein Array beibehalten müssen, kopieren Sie seine Elemente in ein neues, längeres Array und verwenden Sie das zurückgegebene Array.
Alle fünf Java-Beispiele unten wurden in der bereitgestellten Laufzeit erfolgreich ausgeführt; jedes hatte den Exit-Code 0.
Stack.push() für das LIFO-Verhalten verwenden
Stack.push() legt ein Element oben auf einen Last-in-first-out-Stack (LIFO). Daher wird das zuletzt hinzugefügte Element als Erstes von pop() zurückgegeben. Das Beispiel fügt drei Zeichenfolgen hinzu und gibt anschließend das oberste Element aus und entfernt es.
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]
Verwenden Sie diese API, wenn spätere Werte vor früheren verarbeitet werden sollen, etwa beim Verfolgen von Rückgängig-Aktionen oder ausstehender Arbeit. Der angezeigte Stack enthält die übrigen Elemente, nachdem pop() das oberste entfernt hat. Wenn Sie Werte lediglich in ihrer ursprünglichen Reihenfolge behalten möchten, benötigen Sie das Stack-Verhalten nicht; verwenden Sie stattdessen eine Liste, an deren Ende Sie Elemente anhängen.
LinkedList.push() zum Einfügen am Anfang verwenden
LinkedList.push() fügt ein Element am Anfang ein, statt es ans Ende anzuhängen. Jeder weitere Aufruf wird zum neuen ersten Element. Deshalb entspricht die Reihenfolge der Liste der umgekehrten Aufrufreihenfolge.
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]
Auch dies ist ein Einfügevorgang am Anfang: Bei der Ausgabe steht daher der neueste Wert zuerst. Verwenden Sie diese Methode, wenn genau diese Reihenfolge gewünscht ist, zum Beispiel für eine Folge, deren neuestes Element vorne stehen soll. Soll ein Element ans Ende, wählen Sie stattdessen ArrayList.add(); obwohl beide Aufrufe ein Element zu einer Collection hinzufügen, liefern sie unterschiedliche Ergebnisse.
ArrayList.add() zum Anhängen an eine dynamisch wachsende Liste verwenden
Verwenden Sie ArrayList.add(), wenn Sie Werte an eine Liste anhängen möchten, die wachsen kann. Der Aufruf fügt jeden Wert am Ende ein. Eine ArrayList ist eine Collection und kein Java-Array; sie hat daher nicht die feste Länge eines Arrays.
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]
Dies ist die passende Collection-Alternative, wenn mit „einem Array etwas hinzufügen“ gemeint ist, die bestehende Reihenfolge beizubehalten und einen weiteren Wert hinter dem letzten Element abzulegen. Die Liste kann mit den hinzugefügten Werten wachsen. Bei add() muss der Aufrufer nicht für jeden Wert ein größeres Array anlegen und neu zuweisen. Verwenden Sie ein Array mit fester Länge, wenn diese Länge zur Datenstruktur gehört oder von einer anderen API verlangt wird. Eine Liste eignet sich, wenn sich die Anzahl der Werte ändern kann und das Anhängen ans Ende gewünscht ist.
Mit einer benutzerdefinierten Methode an ein Java-Array anhängen
Eine benutzerdefinierte push()-Methode kann ein längeres Array zurückgeben, das die ursprünglichen Elemente und den neuen Wert enthält. Da Java-Arrays nicht an Ort und Stelle wachsen, muss der Aufrufer das zurückgegebene Array zuweisen. Das Kopieren benötigt Zeit proportional zur Anzahl der vorhandenen Elemente und Speicher für das neue 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]
Die zurückgegebene Referenz ist entscheidend: Das ursprüngliche Array behält seine Länge, während push() ein separates Array erstellt und zurückgibt. Wenn Sie das Ergebnis zuweisen, verwenden nachfolgende Zugriffe das längere Array. Wird der Rückgabewert ignoriert, arbeitet der Aufrufer weiterhin mit dem ursprünglichen Array. Dieser Ansatz ist nützlich, wenn eine Methodensignatur oder Bibliothek ein Array verlangt. Bei jedem weiteren Aufruf werden die bereits vorhandenen Elemente erneut kopiert. Für mehrere Ergänzungen ist eine dynamisch wachsende Collection daher meist einfacher und erspart Ihnen diese Kopierlogik.
ArrayDeque.push() für einen Stack verwenden
Für neuen Stack-Code ist ArrayDeque eine dynamisch wachsende Deque, die Einfügen und Entfernen an beiden Enden unterstützt. Ihre Methode push() fügt am Anfang ein, und pop() entfernt ein Element vom selben Ende; so entsteht das LIFO-Verhalten. Beim Durchlaufen beginnt die Deque am Anfang.
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]
Für Stack-Verhalten bietet ArrayDeque.push() dasselbe Prinzip „zuletzt hinein, zuerst heraus“ wie Stack.push(). Die Deque unterstützt außerdem Operationen am anderen Ende. Verwenden Sie sie, wenn Sie einen Stack und dafür eine Deque-Collection benötigen. Wenn das gewünschte Ergebnis eine geordnete Liste mit neuen Elementen am Ende ist, verwenden Sie ArrayList.add(). Entscheidend ist, an welcher Stelle Werte eingefügt und wie sie wieder abgerufen werden sollen – Java-Arrays selbst haben keine eingebaute Push-Operation.