Hvordan du kan snu en liste i java
Å snu en liste i Java i dag er ikke grei. Det er grunnen til at denne artikkelen er skrevet. Teknisk sett er en liste i Java et grensesnitt. Et grensesnitt er en klasse med metodesignaturer som ikke har definisjoner. En klasse må implementeres fra dette grensesnittet før objekter i den implementerte klassen kan bli instantiert. I den implementerte klassen er metodene definert.
Det er en klasse, fremdeles kalt liste, i Java. Imidlertid er denne klassen ment for strengelementer for listen. En liste trenger ikke bare å bestå av strenger. En liste kan bestå av alle flottører, alle dobler, alle heltall osv. Hver av disse typene, må reverseres, avhengig av problemet for hånden. Så denne klassen er ikke nevnt videre i denne artikkelen for strenglisten. Å reversere en liste i denne artikkelen refererer til listegrensesnittet som er gjort til en klasse og et objekt.
Det er Java forhåndsdefinerte listeklasser implementert fra listegrensesnittet. Disse listeklassene er: AbstractList, AbstractSequentlist, ArrayList, Attributelist, CopyOnWriteArrayList, LinkedList, Rolelist, RoleResolvedlist, Stack og Vector.
De fleste av disse listeklassene er i Java.util.* pakke.
Klassesamlinger
Samlingsklassen er også i Java.util.* pakke. Samlingsklassen har en statisk omvendt () -metode som returnerer tomrom. Statisk metode betyr at samlingsklassen ikke trenger å bli instantiert før omvendt metode brukes. Denne metoden vil ta noen av de forrige listeobjektene som et argument og snu det.
Noen uttrykk kan returnere et listeobjekt for generell formål. Samlingene omvendt metode vil også reversere dette listeobjektet når det gis som et argument.
Syntaks for samlingene omvendt () er:
statisk tomrom omvendt (liste liste)Reverserer manuelt
Et listeobjekt i Java kan også reverseres manuelt. To av disse manuelle metodene er også forklart i denne artikkelen.
Reverser ved bruk av samlingene omvendt metode
Reversing en forhåndsdefinert liste
Følgende program reverserer en arraylist av alfabet:
public class theclass
public static void main (String [] args)
ArrayList
al.Legg til ('V'); al.legg til ('w'); al.legg til ('x'); al.legg til ('y'); al.legg til ('z');
Samlinger.omvendt (al);
System.ute.println (al);
Utgangen er:
[Z, Y, X, W, V]for et innspill av,
[V, W, X, Y, Z]Legg merke til hvordan samlingsklassen og den omvendte () metoden er brukt.
Reversing en General Purpose Returned List
Anta at ARR er en rekke karakterer. Klassen, matriser, i javaen.util.* Pakke, har den statiske metoden, ASList (), som vil ta ARR som et argument og returnere en liste over fast størrelse med de samme tegnene. Den statiske omvendte metoden i samlingsklassen vil fortsatt reversere denne listen. Følgende program illustrerer dette:
Importer Java.util.*;public class theclass
public static void main (String [] args)
Karakter [] arr = new Character [] 'v', 'w', 'x', 'y', 'z';
Liste
Samlinger.omvendt (LST);
System.ute.Println (LST);
Utgangen er:
[Z, Y, X, W, V]Reversing en liste manuelt i Java
En måte en matrise kan reverseres på er ved å bytte elementene. Det siste elementet byttes med det første; Den siste-men-en byttes med den andre; Den tredje til den siste byttes med den tredje; og så videre. To indekser, I og J, er nødvendige for denne prosessen. Indeksen jeg er fra begynnelsen, og j er fra slutten. I prosessen, bytt karies på mens jeg er mindre enn J. Alle elementene byttes ut hvis listen har en jevn tallstørrelse. Hvis listen har en oddetallstørrelse, forblir det midterste elementet på sin posisjon. Denne måten å reversere skal brukes med lister og matriser i fast størrelse og matriser.
Den andre måten å reverse manuelt på kan illustreres som følger:
Her er listen som skal reverseres:
V, W, X, Y, ZDet siste elementet, Z, blir fjernet og settes inn i den første posisjonen for at listen blir:
Z, V, W, X, YDet nye siste elementet blir fjernet og settes inn i den andre posisjonen for at listen skal bli:
Z, Y, V, W, XDet nye siste elementet blir fjernet og settes inn i den tredje posisjonen for at listen skal bli:
Z, y, x, v, wDet nye siste elementet blir fjernet og settes inn i fjerde plassering for at listen blir:
Z, y, x, w, vMerk at størrelsen på listen aldri endret for hvert resultat. I dette tilfellet, hvis J var indeksen for det siste elementet, ville ikke verdien av j endres i prosessen. Mens verdien av indeks I, fra begynnelsen, ville endres fra 0 til 3. Så jeg blir økt til det er rett under J med en enhet. Denne måten å reversere på er den fjerne og innsatsmåten.
På denne måten kan ikke brukes med listen over fast størrelse fordi et element ikke kan fjernes med listen over fast størrelse.
Reverserer ved å bytte
Den viktigste metoden å bruke her er SET () -metoden til listegrensesnittet, hvis komplette syntaks er:
E Set (int -indeks, E -element)Det første argumentet for denne metoden er indeksen for et bestemt element i listen. Det andre argumentet er elementet som erstatter elementet i indeksposisjonen. Følgende program bytter for en liste over fast størrelse.
Importer Java.util.*;public class theclass
public static void main (String [] args)
Karakter [] arr = new Character [] 'v', 'w', 'x', 'y', 'z';
Liste
int j = lst.størrelse () - 1;
for (int i = 0; i
lst.sett (j, lst.få (i));
lst.sett (i, temp);
j--;
System.ute.Println (LST);
Utgangen er:
[Z, Y, X, W, V]Byttingen bruker den klassiske koden for å bytte to verdier. I dette tilfellet er koden:
char temp = lst.få (j);lst.sett (j, lst.få (i));
lst.sett (i, temp);
I initialiseringsuttalelsen er det mulig å initialisere j i for-loop. Det er også mulig å redusere j i neste-iterasjonserklæring av for-loop. To uttrykk, i dette tilfellet, er atskilt med komma. Den forrige for-loopen er kodet på nytt som følger:
Importer Java.util.*;public class theclass
public static void main (String [] args)
Karakter [] arr = new Character [] 'v', 'w', 'x', 'y', 'z';
Liste
for (int i = 0, j = lst.størrelse () - 1; Jeg
lst.sett (j, lst.få (i));
lst.sett (i, temp);
System.ute.Println (LST);
Her håndterer en en-for-loop to variabler. Utgangen er den samme, som vist nedenfor:
[Z, Y, X, W, V]Reversering ved å fjerne og sette inn
Fjern-and-Insert Way kan ikke fungere med den returnerte listen over fast størrelse. Imidlertid kan det fungere med de forhåndsdefinerte listeklassene. På denne måten bruker listenes add () -metode, hvis syntaks er:
void add (int indeks, e element)"Legg til" her betyr innsetting. Det vil si: sett inn elementet E på den angitte indeksen. Etter innsetting blir alle elementene til høyre forskjøvet ett sted.
Den bruker også Fjern () -metoden, hvis syntaks er:
E Fjern (int -indeks)Dette betyr: å fjerne elementet ved den spesifiserte indeksen og returnere det. Følgende program fjerner og Insert (for reversering):
Importer Java.util.*;public class theclass
public static void main (String [] args)
ArrayList
al.Legg til ('V'); al.legg til ('w'); al.legg til ('x'); al.legg til ('y'); al.legg til ('z');
int j = al.størrelse () - 1;
for (int i = 0; i
al.Legg til (i, temp);
System.ute.println (al);
Utgangen er:
[Z, Y, X, W, V]Som forventet og for dette programmet endres ikke verdien av j fra et generelt synspunkt.
Det er mulig å initialisere J i initialiseringsuttalelsen i for-loop. To uttrykk, i dette tilfellet, er atskilt med komma. Den forrige for-loopen er kodet på nytt som følger:
Importer Java.util.*;public class theclass
public static void main (String [] args)
ArrayList
al.Legg til ('V'); al.legg til ('w'); al.legg til ('x'); al.legg til ('y'); al.legg til ('z');
for (int i = 0, j = al.størrelse () - 1; Jeg
System.ute.println (al);
Utgangen er:
[Z, Y, X, W, V]Som forventet.
Konklusjon
Denne artikkelen forklarte at en liste kunne reverseres ved å bruke den statiske omvendte () -metoden i samlingsklassen, der listeobjektet blir metodens argument. I tillegg kan en liste også reverseres manuelt ved å bytte elementer eller ved å bruke fjerning og innsats. Vi håper du fant denne artikkelen nyttig. Sjekk de andre Linux -hint -artiklene for flere tips og opplæringsprogrammer.