Comment inverser une liste dans Java
Inversion d'une liste dans Java aujourd'hui n'est pas simple. C'est pourquoi cet article est écrit. Techniquement, une liste en Java est une interface. Une interface est une classe avec des signatures de méthode qui n'ont pas de définitions. Une classe doit être implémentée à partir de cette interface avant que les objets de la classe implémentés puissent être instanciés. Dans la classe implémentée, les méthodes sont définies.
Il y a une classe, toujours appelée liste, en java. Cependant, cette classe est destinée aux éléments de chaîne pour la liste. Une liste ne doit pas seulement être composée de chaînes. Une liste peut être composée de tous les flotteurs, tous les doubles, tous les entiers, etc. Chacun de ces types devrait être inversé, selon le problème à portée de main. Cette classe n'est donc plus mentionnée dans cet article pour la liste des chaînes. L'inversion d'une liste dans cet article fait référence à l'interface de liste transformée en classe et un objet.
Il existe des classes de liste prédéfinie Java implémentées à partir de l'interface de liste. Ces classes de liste sont: AbstractList, AbstractSeventialList, ArrayList, AttributeList, CopyOnwriteArrayList, LinkedList, Rolelist, RoleUnResolvedList, Stack et The Vector.
La plupart de ces classes de liste sont dans le java.user.* emballer.
Collections de classe
La classe de collections est également dans le java.user.* emballer. La classe de collections a une méthode inverse () statique qui renvoie vide. La méthode statique signifie que la classe de collections ne doit pas être instanciée avant que la méthode inverse ne soit utilisée. Cette méthode prendra l'un des objets de liste précédente comme argument et l'inversera.
Certaines expressions peuvent renvoyer un objet de liste à usage général. La méthode de revers des collections inversera également cet objet de liste lorsqu'il est donné comme argument.
La syntaxe des collections reverse () est:
STATIC VOID ROINDE (LISTE LISTE)Inverser manuellement
Un objet de liste dans Java peut également être inversé manuellement. Deux de ces méthodes manuelles sont également expliquées dans cet article.
Inversion à l'aide de la méthode inverse des collections
Inversion d'une liste prédéfinie
Le programme suivant inverse une arraylist d'alphabets:
classe publique TheClass
public static void main (String [] args)
Liste des tableaux
Al.ajouter ('v'); Al.ajouter ('w'); Al.ajouter ('x'); Al.ajouter ('y'); Al.ajouter ('z');
Collections.inverse (al);
Système.dehors.println (al);
La sortie est:
[Z, y, x, w, v]pour une entrée de,
[V, w, x, y, z]Notez la façon dont la classe de collections et sa méthode Reverse () ont été utilisées.
Inversion d'une liste retournée à des fins générales
Supposons que ARR est un éventail de personnages. La classe, les tableaux, dans le java.user.* Package, a la méthode statique, aslist (), qui prendrait ARR comme argument et renverra une liste à usage général de taille fixe avec les mêmes caractères. La méthode inverse statique de la classe des collections inverserait toujours cette liste. Le programme suivant illustre ceci:
Importer Java.user.*classe publique TheClass
public static void main (String [] args)
Caractère [] arr = nouveau caractère [] 'v', 'w', 'x', 'y', 'z';
Liste
Collections.inversé (LST);
Système.dehors.println (LST);
La sortie est:
[Z, y, x, w, v]Inverser une liste manuellement en java
Une façon dont un tableau peut être inversé est en échangeant les éléments. Le dernier élément est échangé avec le premier; Le dernier mais un est échangé avec le second; Le troisième au dernier est échangé avec le troisième; et ainsi de suite. Deux index, I et J, sont nécessaires pour ce processus. L'index I est depuis le début, et J est de la fin. Dans le processus, échanger des caries pendant que je suis inférieur à J. Tous les éléments sont échangés si la liste a une taille de nombre uniforme. Si la liste a une taille de nombre impair, alors l'élément central reste à sa position. Cette façon de remonter doit être utilisée avec des listes de taille fixe et des tableaux.
L'autre façon de renverser manuellement peut être illustrée comme suit:
Voici la liste à inverser:
V, w, x, y, zLe dernier élément, Z, est supprimé et inséré dans la première position pour que la liste devienne:
Z, v, w, x, yLe nouveau dernier élément est supprimé et inséré dans la deuxième position pour que la liste devienne:
Z, y, v, w, xLe nouveau dernier élément est supprimé et inséré dans la troisième position pour que la liste devienne:
Z, y, x, v, wLe nouveau dernier élément est supprimé et inséré dans la quatrième position pour que la liste devienne:
Z, y, x, w, vNotez que la taille de la liste n'a jamais changé pour chaque résultat. Dans ce cas, si j était l'indice du dernier élément, alors la valeur de J ne changerait pas dans le processus. Tandis que la valeur de l'index I, depuis le début, passerait de 0 à 3. Donc, je suis incrémenté jusqu'à ce qu'il soit juste en dessous de J par une unité. Cette façon de s'inverser est la manière de supprimer et d'inserter.
Cette manière ne peut pas être utilisée avec la liste de taille fixe car un élément ne peut pas être supprimé avec la liste de taille fixe.
Inversion en échangeant
La méthode principale à utiliser ici est la méthode set () de l'interface de liste, dont la syntaxe complète est:
E Set (int index, e élément)Le premier argument pour cette méthode est l'indice d'un élément particulier de la liste. Le deuxième argument est l'élément pour remplacer l'élément en position d'index. Le programme suivant échange par une liste de taille fixe.
Importer Java.user.*classe publique TheClass
public static void main (String [] args)
Caractère [] arr = nouveau caractère [] 'v', 'w', 'x', 'y', 'z';
Liste
int j = lst.size () - 1;
pour (int i = 0; i
qui.set (J, LST.obtenir (i));
qui.set (i, temp);
J-;
Système.dehors.println (LST);
La sortie est:
[Z, y, x, w, v]L'échange utilise le code classique pour échanger deux valeurs. Dans ce cas, le code est:
Char Temp = LST.obtenir (j);qui.set (J, LST.obtenir (i));
qui.set (i, temp);
Dans l'instruction d'initialisation, il est possible d'initialiser J dans la boucle. Il est également possible de décrémenter J dans l'énoncé d'itération suivante de la boucle pour. Dans ce cas, deux expressions sont séparées par une virgule. La boucle pour la boucle précédente est re-codée comme suit:
Importer Java.user.*classe publique TheClass
public static void main (String [] args)
Caractère [] arr = nouveau caractère [] 'v', 'w', 'x', 'y', 'z';
Liste
pour (int i = 0, j = lst.size () - 1; je
qui.set (J, LST.obtenir (i));
qui.set (i, temp);
Système.dehors.println (LST);
Ici, une boucle unique gère deux variables. La sortie est la même, comme indiqué ci-dessous:
[Z, y, x, w, v]Inversion par la suppression et l'insertion
La manière de supprimer et d'inserter ne peut pas fonctionner avec la liste de taille fixe renvoyée. Cependant, cela peut fonctionner avec les classes de liste prédéfinie. Cette manière utilise la méthode Add () de la liste, dont la syntaxe est:
void add (int index, e élément)Le «ajouter» signifie ici insérer. C'est-à-dire: insérer l'élément E à l'index spécifié. Après l'insertion, tous les éléments à droite sont déplacés un endroit.
Il utilise également la méthode supprime (), dont la syntaxe est:
E REPOUR (INT INDEX)Cela signifie: supprimer l'élément à l'indice spécifié et le renvoyer. Le programme suivant est en supprime et à l'insertion (pour inverser):
Importer Java.user.*classe publique TheClass
public static void main (String [] args)
Liste des tableaux
Al.ajouter ('v'); Al.ajouter ('w'); Al.ajouter ('x'); Al.ajouter ('y'); Al.ajouter ('z');
int j = al.size () - 1;
pour (int i = 0; i
Al.Ajouter (i, temp);
Système.dehors.println (al);
La sortie est:
[Z, y, x, w, v]Comme prévu et pour ce programme, la valeur de J ne change pas d'un point de vue général.
Il est possible d'initialiser J dans l'instruction d'initialisation dans la boucle for. Dans ce cas, deux expressions sont séparées par une virgule. La boucle pour la boucle précédente est re-codée comme suit:
Importer Java.user.*classe publique TheClass
public static void main (String [] args)
Liste des tableaux
Al.ajouter ('v'); Al.ajouter ('w'); Al.ajouter ('x'); Al.ajouter ('y'); Al.ajouter ('z');
pour (int i = 0, j = al.size () - 1; je
Système.dehors.println (al);
La sortie est:
[Z, y, x, w, v]Comme prévu.
Conclusion
Cet article a expliqué qu'une liste pourrait être inversée en utilisant la méthode statique inverse () de la classe de collections, où l'objet de liste devient l'argument de la méthode. De plus, une liste peut également être inversée manuellement en échangeant des éléments ou en utilisant la suppression et l'insertion. Nous espérons que vous avez trouvé cet article utile. Consultez les autres articles sur les conseils pour plus de conseils et de tutoriels.