Come invertire un elenco in Java
Invertire un elenco in Java oggi non è semplice. Ecco perché questo articolo è scritto. Tecnicamente, un elenco in Java è un'interfaccia. Un'interfaccia è una classe con firme del metodo che non hanno definizioni. Una classe deve essere implementata da questa interfaccia prima che gli oggetti della classe implementati possano essere istanziati. Nella classe implementata, i metodi sono definiti.
C'è una classe, ancora chiamata elenco, in Java. Tuttavia, questa classe è pensata per gli elementi di stringa per l'elenco. Un elenco non deve solo essere costituito da stringhe. Un elenco può consistere in tutti i galleggianti, tutti i doppi, tutti i numeri interi, ecc. Ognuno di questi tipi dovrebbe essere invertito, a seconda del problema a portata di mano. Quindi questa classe non è più menzionata in questo articolo per l'elenco delle stringhe. Invertire un elenco in questo articolo si riferisce all'interfaccia dell'elenco trasformata in una classe e un oggetto.
Ci sono classi di elenco predefinite Java implementate dall'interfaccia dell'elenco. Queste classi di elenchi sono: ExtractList, AbstractEquentialList, ArrayList, Attributelist, CopyOnWriteArrayList, LinkedList, Rolelist, RoleUnResolvedList, Stack e The Vector.
La maggior parte di queste classi di elenchi sono nel Java.util.* pacchetto.
Collezioni di classe
La lezione di collezioni è anche nel Java.util.* pacchetto. La classe di raccolte ha un metodo statico di reverse () che restituisce vuoto. Metodo statico significa che la classe di raccolte non deve essere istanziata prima che venga utilizzato il metodo inverso. Questo metodo prenderà uno qualsiasi degli oggetti dell'elenco precedente come argomento e invertirlo.
Alcune espressioni possono restituire un oggetto dell'elenco per scopi generali. Il metodo inverso delle raccolte invertirà anche questo oggetto elenco quando viene fornito come argomento.
La sintassi per il metodo delle raccolte reverse () è:
statico vuoto inverso (elenco elenco)Invertire manualmente
Un oggetto elenco in Java può anche essere invertito manualmente. In questo articolo sono anche spiegati due di questi metodi manuali.
Invertire l'utilizzo del metodo inverso delle raccolte
Invertire un elenco predefinito
Il seguente programma inverte un arraylist di alfabeti:
Classe pubblica TheClass
public static void main (string [] args)
Lista di array
al.Aggiungi ('V'); al.Aggiungi ('W'); al.Aggiungi ('x'); al.Aggiungi ('y'); al.Aggiungi ('z');
Collezioni.inverso (al);
Sistema.fuori.println (al);
L'output è:
[Z, Y, X, W, V]per un input di,
[V, W, X, Y, Z]Nota il modo in cui sono state utilizzate la classe di raccolte e il suo metodo inverso ().
Invertire un elenco restituito agli scopi generici
Supponiamo che ARR sia un array di personaggi. La classe, array, nel Java.util.* pacchetto, ha il metodo statico, aslist (), che richiederebbe un argomento e restituirebbe un elenco di scopi generali di dimensioni fisse con gli stessi caratteri. Il metodo inverso statico della classe di raccolte farebbe ancora invertire questo elenco. Il seguente programma illustra questo:
Importa Java.util.*;Classe pubblica TheClass
public static void main (string [] args)
Caratteri [] arr = new carattere [] 'v', 'w', 'x', 'y', 'z';
Elenco
Collezioni.retromarcia (LST);
Sistema.fuori.println (lst);
L'output è:
[Z, Y, X, W, V]Invertire un elenco manualmente in java
Un modo in cui un array può essere invertito è scambiare gli elementi. L'ultimo elemento viene scambiato con il primo; L'ultimo ma uno viene scambiato con il secondo; Il terzo all'ultimo viene scambiato con il terzo; e così via. Per questo processo sono necessari due indici, io e j. L'indice i è dall'inizio e J è dalla fine. Nel processo, scambiare carie mentre sono meno di j. Tutti gli elementi sono scambiati se l'elenco ha una dimensione del numero pari. Se l'elenco ha una dimensione del numero dispari, l'elemento centrale rimane nella sua posizione. Questo modo di invertire dovrebbe essere utilizzato con elenchi e array di dimensioni fisse.
L'altro modo di invertire manualmente può essere illustrato come segue:
Ecco l'elenco da invertire:
V, w, x, y, zL'ultimo elemento, Z, viene rimosso e inserito nella prima posizione affinché l'elenco diventasse:
Z, v, w, x, yIl nuovo ultimo elemento viene rimosso e inserito nella seconda posizione affinché l'elenco diventasse:
Z, y, v, w, xIl nuovo ultimo elemento viene rimosso e inserito nella terza posizione affinché l'elenco diventi:
Z, y, x, v, wIl nuovo ultimo elemento viene rimosso e inserito nella quarta posizione affinché l'elenco diventasse:
Z, y, x, w, vSi noti che la dimensione dell'elenco non è mai cambiata per ciascun risultato. In questo caso, se J fosse l'indice dell'ultimo elemento, il valore di J non cambierebbe nel processo. Mentre il valore dell'indice I, dall'inizio, cambierebbe da 0 a 3. Quindi, sono incrementato fino a quando non è appena sotto J per un'unità. Questo modo di invertire è il modo di rimuovere e inserire.
In questo modo non può essere utilizzato con l'elenco di dimensioni fisse perché un elemento non può essere rimosso con l'elenco delle dimensioni fisse.
Invertire lo scambio
Il metodo principale da utilizzare qui è il metodo set () dell'interfaccia dell'elenco, la cui sintassi completa è:
E set (indice int, elemento e)Il primo argomento per questo metodo è l'indice di un particolare elemento nell'elenco. Il secondo argomento è l'elemento per sostituire l'elemento nella posizione dell'indice. Il seguente programma si scambia con un elenco di dimensioni fisse.
Importa Java.util.*;Classe pubblica TheClass
public static void main (string [] args)
Caratteri [] arr = new carattere [] 'v', 'w', 'x', 'y', 'z';
Elenco
int j = lst.size () - 1;
per (int i = 0; i
LST.Set (J, LST.ottenere (i));
LST.set (i, temp);
J--;
Sistema.fuori.println (lst);
L'output è:
[Z, Y, X, W, V]Lo scambio utilizza il codice classico per lo scambio di due valori. In questo caso, il codice è:
char temp = lst.ottenere (j);LST.Set (J, LST.ottenere (i));
LST.set (i, temp);
Nell'istruzione di inizializzazione, è possibile inizializzare J nel per loop per loop. È anche possibile decrementare J nella dichiarazione di prossima iterazioni del per loop per loop. Due espressioni, in questo caso, sono separate da una virgola. Il precedente per loop viene ri-codificato come segue:
Importa Java.util.*;Classe pubblica TheClass
public static void main (string [] args)
Caratteri [] arr = new carattere [] 'v', 'w', 'x', 'y', 'z';
Elenco
per (int i = 0, j = lst.size () - 1; io
LST.Set (J, LST.ottenere (i));
LST.set (i, temp);
Sistema.fuori.println (lst);
Qui, un loop a una per gestire due variabili. L'output è lo stesso, come mostrato di seguito:
[Z, Y, X, W, V]Invertire per rimuovere e inserire
Il modo di rimuovere e inserire non può funzionare con l'elenco di dimensioni fisse restituite. Tuttavia, può funzionare con le classi di elenco predefinite. In questo modo utilizza il metodo Add () dell'elenco, la cui sintassi è:
void aggiungi (indice int, elemento e)Il "Aggiungi" qui significa inserire. Cioè: inserire l'elemento E all'indice specificato. Dopo l'inserimento, tutti gli elementi a destra vengono spostati un posto.
Utilizza anche il metodo remove (), la cui sintassi è:
E rimuovere (indice int)Ciò significa: rimozione dell'elemento all'indice specificato e restituirlo. Il seguente programma rimuove e inserisce (per invertire):
Importa Java.util.*;Classe pubblica TheClass
public static void main (string [] args)
Lista di array
al.Aggiungi ('V'); al.Aggiungi ('W'); al.Aggiungi ('x'); al.Aggiungi ('y'); al.Aggiungi ('z');
int j = al.size () - 1;
per (int i = 0; i
al.Aggiungi (i, temp);
Sistema.fuori.println (al);
L'output è:
[Z, Y, X, W, V]Come previsto e per questo programma, il valore di J non cambia dal punto di vista generale.
È possibile inizializzare J nell'istruzione di inizializzazione. Due espressioni, in questo caso, sono separate da una virgola. Il precedente per loop viene ri-codificato come segue:
Importa Java.util.*;Classe pubblica TheClass
public static void main (string [] args)
Lista di array
al.Aggiungi ('V'); al.Aggiungi ('W'); al.Aggiungi ('x'); al.Aggiungi ('y'); al.Aggiungi ('z');
per (int i = 0, j = al.size () - 1; io
Sistema.fuori.println (al);
L'output è:
[Z, Y, X, W, V]Come previsto.
Conclusione
Questo articolo ha spiegato che un elenco potrebbe essere invertito utilizzando il metodo statico inverso () della classe di raccolte, in cui l'oggetto elenco diventa l'argomento del metodo. Inoltre, un elenco può anche essere invertito manualmente scambiando elementi o utilizzando il rimozione e l'inserimento. Speriamo che tu abbia trovato questo articolo utile. Controlla gli altri articoli di suggerimento Linux per ulteriori suggerimenti e tutorial.