Wie man eine Liste in Java umgeht
Die Umkehrung einer Liste in Java heute ist nicht einfach. Deshalb ist dieser Artikel geschrieben. Technisch gesehen ist eine Liste in Java eine Schnittstelle. Eine Schnittstelle ist eine Klasse mit Methodensignaturen, die keine Definitionen haben. Eine Klasse muss von dieser Schnittstelle implementiert werden, bevor Objekte der implementierten Klasse instanziiert werden können. In der implementierten Klasse werden die Methoden definiert.
In Java gibt es eine Klasse, die noch als Liste bezeichnet wird. Diese Klasse ist jedoch für Stringelemente für die Liste gedacht. Eine Liste muss nicht nur aus Saiten bestehen. Eine Liste kann aus allen Schwimmern, allen Doppel, allen Ganzzahlen usw. bestehen. Jede dieser Typen müsste je nach vorlemem Problem umgekehrt werden. Daher wird diese Klasse in diesem Artikel für die String -Liste nicht weiter erwähnt. Das Umkehren einer Liste in diesem Artikel bezieht sich auf die Listenschnittstelle, die in eine Klasse und ein Objekt gemacht wurde.
Es gibt Java -vordefinierte Listenklassen, die von der List -Schnittstelle implementiert sind. Diese Listenklassen sind: AbstractList, AbstractSequentialList, ArrayList, Attributelist, CopyonWriteArrayList, LinkedList, Rolelist, RollenunresolvedList, Stack und The Vector.
Die meisten dieser Listenklassen befinden sich in der Java.Util.* Paket.
Klassensammlungen
Die Sammlungsklasse befindet sich auch in der Java.Util.* Paket. Die Sammlungsklasse hat eine statische Reverse () -Methode, die Leere zurückgibt. Statisch-Methoden bedeutet, dass die Sammlungsklasse nicht instanziiert werden muss, bevor die umgekehrte Methode verwendet wird. Diese Methode nimmt eines der vorherigen Listenobjekte als Argument an und kehrt sie um.
Einige Ausdrücke können ein allgemeines Listenobjekt zurückgeben. Die Reverse -Methode der Sammlungen wird dieses Listenobjekt auch umkehren, wenn sie als Argument angegeben werden.
Die Syntax für die Sammlungsmethode Reverse () lautet:
statische Void Reverse (Listenliste)Manuell umkehren
Ein Listenobjekt in Java kann auch manuell umgekehrt werden. In diesem Artikel werden auch zwei dieser manuellen Methoden erläutert.
Umkehrung mithilfe der Sammlungsverkehrsmethode
Umkehrung einer vordefinierten Liste
Das folgende Programm kehrt eine Arraylist mit Alphabeten um:
öffentliche Klasse Theclass
public static void main (String [] args)
Anordnungsliste
al.add ('v'); al.add ('w'); al.add ('x'); al.add ('y'); al.add ('z');
Sammlungen.reverse (al);
System.aus.println (al);
Die Ausgabe ist:
[Z, Y, X, W, V]für einen Eingang von,
[V, W, X, Y, Z]Beachten Sie, wie die Sammlungsklasse und ihre Reverse () -Methode verwendet wurden.
Umkehrung einer allgemeinen zurückgegebenen Liste
Angenommen, ARR ist eine Reihe von Zeichen. Die Klasse, Arrays, in der Java.Util.* Paket, hat die statische Methode, ASList (), die arr als Argument betrachten und eine allgemeine Liste mit fester Größe mit denselben Zeichen zurückgeben würde. Die statische umgekehrte Methode der Sammlungsklasse würde diese Liste immer wieder umkehren. Das folgende Programm zeigt dies:
Java importieren.Util.*;öffentliche Klasse Theclass
public static void main (String [] args)
Charakter [] arr = new Zeichen [] 'v', 'w', 'x', 'y', 'z';
Aufführen
Sammlungen.reverse (lst);
System.aus.println (lst);
Die Ausgabe ist:
[Z, Y, X, W, V]Eine Liste manuell in Java umkehren
Eine Möglichkeit, wie ein Array umgekehrt werden kann, besteht darin, die Elemente auszutauschen. Das letzte Element wird mit dem ersten ausgetauscht; Der letzte, aber eins wird mit dem zweiten ausgetauscht; Der dritte bis zum letzten wird mit dem dritten ausgetauscht; usw. Für diesen Prozess werden zwei Indizes, I und J, benötigt. Der Index I ist von Anfang an und J vom Ende ist. Dabei der Karies eintauschen, während ich weniger als J ist. Alle Elemente werden austauscht, wenn die Liste eine gleichmäßige Zahlengröße hat. Wenn die Liste eine ungerade Zahlengröße hat, bleibt das mittlere Element an ihrer Position. Diese Umkehrweise sollte mit Listen und Arrays fester Größe verwendet werden.
Die andere Möglichkeit, manuell umzukehren, kann wie folgt veranschaulicht werden:
Hier ist die Liste, die umgekehrt werden soll:
V, w, x, y, zDas letzte Element, Z, wird entfernt und in die erste Position eingefügt, damit die Liste wird:
Z, v, w, x, yDas neue letzte Element wird entfernt und in die zweite Position eingefügt, damit die Liste wird:
Z, y, v, w, xDas neue letzte Element wird entfernt und in die dritte Position eingefügt, damit die Liste wird:
Z, y, x, v, wDas neue letzte Element wird entfernt und in die vierte Position eingefügt, damit die Liste wird:
Z, y, x, w, vBeachten Sie, dass sich die Größe der Liste für jedes Ergebnis nie geändert hat. In diesem Fall würde sich der Wert von J im Prozess nicht ändern, wenn j der Index des letzten Elements wäre. Während sich der Wert von Index I von Anfang an von 0 auf 3 ändern würde. Also bin ich inkrementiert, bis es knapp unter j von einer Einheit liegt. Diese Art der Umkehrung ist der Weg zur Entfernung und Insserie.
Auf diese Weise kann nicht mit der Liste fester Größe verwendet werden, da ein Element mit der Liste fester Größe nicht entfernt werden kann.
Umkehrung durch Austausch
Die Hauptmethode, die hier verwendet werden soll, ist die set () -Methode der List -Schnittstelle, deren vollständige Syntax lautet:
E set (int index, e element)Das erste Argument für diese Methode ist der Index eines bestimmten Elements in der Liste. Das zweite Argument ist das Element, das das Element an der Indexposition ersetzt. Das folgende Programm tausch.
Java importieren.Util.*;öffentliche Klasse Theclass
public static void main (String [] args)
Charakter [] arr = new Zeichen [] 'v', 'w', 'x', 'y', 'z';
Aufführen
int j = lst.size () - 1;
für (int i = 0; i
lst.set (j, lst.bekomme ich));
lst.set (i, temp);
J--;
System.aus.println (lst);
Die Ausgabe ist:
[Z, Y, X, W, V]Der Tausch verwendet den klassischen Code zum Austausch von zwei Werten. In diesem Fall lautet der Code:
char temp = lst.Holen Sie sich (j);lst.set (j, lst.bekomme ich));
lst.set (i, temp);
In der Initialisierungsanweisung ist es möglich, J in der For-Schleife zu initialisieren. Es ist auch möglich, J in der Aussage der nächsten Schleife zu verringern. In diesem Fall werden zwei Ausdrücke durch ein Komma getrennt. Die vorherige For-Schleife wird wie folgt neu codiert:
Java importieren.Util.*;öffentliche Klasse Theclass
public static void main (String [] args)
Charakter [] arr = new Zeichen [] 'v', 'w', 'x', 'y', 'z';
Aufführen
für (int i = 0, j = lst.size () - 1; ich
lst.set (j, lst.bekomme ich));
lst.set (i, temp);
System.aus.println (lst);
Hier handelt eine Eins für die Schleife mit zwei Variablen. Der Ausgang ist der gleiche wie unten gezeigt:
[Z, Y, X, W, V]Umkehrung durch Entfernen und Einsetzen
Der Weg zum Entfernen und Einsetzen kann nicht mit der zurückgegebenen Liste fester Größe funktionieren. Es kann jedoch mit den vordefinierten Listenklassen funktionieren. Auf diese Weise verwendet die add () -Methode der Liste, deren Syntax lautet:
void Add (int Index, E Element)Das „Hinzufügen“ hier bedeutet Einfügung. Das heißt: Fügen Sie das Element E am angegebenen Index ein. Nach dem Einsetzen werden alle Elemente auf der rechten Seite um einen Ort verschoben.
Es verwendet auch die Methode von REME () (), deren Syntax lautet:
E entfernen (int Index)Dies bedeutet: Entfernen des Elements im angegebenen Index und zurückzugeben. Das folgende Programm entfernen und einsetzt (zur Umkehrung):
Java importieren.Util.*;öffentliche Klasse Theclass
public static void main (String [] args)
Anordnungsliste
al.add ('v'); al.add ('w'); al.add ('x'); al.add ('y'); al.add ('z');
int j = al.size () - 1;
für (int i = 0; i
al.add (i, temp);
System.aus.println (al);
Die Ausgabe ist:
[Z, Y, X, W, V]Wie erwartet und für dieses Programm ändert sich der Wert von J nicht aus allgemeiner Sicht.
Es ist möglich, J in der Initialisierungsanweisung in der For-Loop zu initialisieren. In diesem Fall werden zwei Ausdrücke durch ein Komma getrennt. Die vorherige For-Schleife wird wie folgt neu codiert:
Java importieren.Util.*;öffentliche Klasse Theclass
public static void main (String [] args)
Anordnungsliste
al.add ('v'); al.add ('w'); al.add ('x'); al.add ('y'); al.add ('z');
für (int i = 0, j = al.size () - 1; ich
System.aus.println (al);
Die Ausgabe ist:
[Z, Y, X, W, V]Wie erwartet.
Abschluss
Dieser Artikel erläuterte eine Liste könnte mit der statischen Reverse () -Methode der Sammlungsklasse umgekehrt werden, wobei das Listenobjekt zum Argument der Methode wird. Außerdem kann eine Liste durch Austausch von Elementen oder durch die Verwendung des Entfernen-und-Unternehmungsvermögens auch manuell umgekehrt werden. Wir hoffen, Sie haben diesen Artikel hilfreich gefunden. Weitere Tipps und Tutorials finden Sie in den anderen Linux -Hinweisartikeln.