La liste Interface (Java - Tutoriaux - Collections - Interfaces)
- accès positionnel # 151; manipule des éléments en fonction de leur position numérique dans la liste. Cela comprend des méthodes telles que obtenir. ensemble. ajouter. tout ajouter. et à enlever.
- Chercher # 151; recherche un objet spécifié dans la liste et renvoie sa position numérique. Les méthodes de recherche comprennent indexOf et lastIndexOf.
- Itération # 151; étend la sémantique Iterator pour tirer parti de la nature séquentielle de la liste. Les méthodes de ListIterator fournissent ce comportement.
- Range-vue # 151; Le procédé exécute des opérations sous-liste de la gamme arbitraires sur la liste.
La plate-forme Java contient deux implémentations Liste d'usage général. ArrayList. qui est généralement la mise en œuvre plus performante et LinkedList qui offre de meilleures performances dans certaines circonstances.
opérations de collecte
Les opérations héritées de la collection font tous ce que vous voulez les attendez d', en supposant que vous êtes déjà familier avec eux. Si vous n'êtes pas familier avec eux de la Collection. maintenant serait un bon moment pour lire la section Interface Collection. L'opération de suppression supprime toujours la première occurrence de l'élément spécifié dans la liste. Ajouter et opérations addAll toujours append le nouvel élément (s) à la fin de la liste. Ainsi, l'idiome suivant concatène une liste à une autre.
Voici une forme non destructive de cet idiome, qui produit une troisième liste constituée de la deuxième liste annexée à la première.
Notez que l'idiome, sous sa forme non destructive, tire profit du constructeur de conversion standard de ArrayList.
Et voici un exemple (8 JDK et versions ultérieures) qui agrège certains noms dans une liste.
Comme l'ensemble d'interface, liste renforce les exigences sur les méthodes equals et hashCode de sorte que deux objets de la liste peuvent être comparés pour l'égalité logique sans tenir compte de leurs cours de mise en œuvre. Deux objets de la liste sont égaux si elles contiennent les mêmes éléments dans le même ordre.
Positionnel accès et opérations de recherche
Les opérations d'accès de position de base sont get. ensemble. ajouter et supprimer. (L'ensemble des opérations et supprimer l'ancienne valeur de retour qui est remplacé ou supprimé.) D'autres opérations (indexOf et lastIndexOf) renvoient le premier ou le dernier index de l'élément spécifié dans la liste.
L'opération addAll insère tous les éléments de la collection spécifiée à partir de la position spécifiée. Les éléments sont insérés dans l'ordre dans lequel ils sont renvoyés par iterator de la collecte. Cet appel est l'analogue d'accès de position de fonctionnement addAll de collection.
Voici un petit méthode pour échanger deux valeurs indexées dans une liste.
Bien sûr, il y a une grande différence. Ceci est un algorithme polymorphes: Il permute deux éléments dans une liste. quel que soit son type de mise en œuvre. Voici un autre algorithme polymorphique qui utilise la méthode d'échange précédent.
Cet algorithme, qui est inclus dans la plate-forme Java de classe Collections, permute au hasard la liste spécifiée en utilisant la source spécifiée de l'aléatoire. Il est un peu subtile: Il fonctionne la liste à partir du bas, en échangeant de façon répétée un élément choisi au hasard dans la position actuelle. Contrairement à la plupart des tentatives naïves brassage, il est juste (toutes les permutations se produisent avec une probabilité égale, en supposant une source impartiale de caractère aléatoire) et rapide (nécessitant exactement list.size () - 1 swaps). Le programme suivant utilise cet algorithme pour imprimer les mots dans sa liste d'arguments dans un ordre aléatoire.
En fait, ce programme peut être encore plus court et plus rapide. La classe Arrays a une méthode statique appelée usine asList. qui permet à un tableau à être considéré comme une liste. Cette méthode ne copie pas le tableau. Les changements dans la liste par écrire au tableau et vice-versa. La liste qui en résulte est pas une mise en œuvre de la liste des fins générales, car il ne met pas en œuvre (en option) ajouter et supprimer des opérations: Les tableaux ne sont pas redimensionnable. Profitant de Arrays.asList et d'appeler la version de la bibliothèque de lecture aléatoire. qui utilise une source de hasard par défaut, vous obtenez le petit programme suivant dont le comportement est identique au programme précédent.
Comme on pouvait s'y attendre, l'itérateur retourné par l'opération de iterator de liste renvoie les éléments de la liste dans le bon ordre. Liste fournit également un iterator plus riche, appelé ListIterators. qui permet de parcourir la liste dans les deux sens, de modifier la liste au cours de l'itération, et obtenir la position courante de l'itérateur.
Les trois méthodes qui ListIterator hérite de iterator (hasNext. Suivant. Et supprimer) font exactement la même chose dans les deux interfaces. Le hasPrevious et les opérations précédentes sont analogues exactes de hasNext et suivant. Les anciennes opérations se rapportent à l'élément avant le curseur (implicite), alors que celui-ci se réfèrent à l'élément après le curseur. L'opération précédente déplace le curseur vers l'arrière, alors que se déplace à venir vers l'avant.
Voici l'idiome standard pour itérer en arrière dans une liste.
Notez l'argument de ListIterator dans l'idiome précédent. L'interface de liste a deux formes de la méthode ListIterator. La forme sans argument renvoie un ListIterator positionné au début de la liste; sous la forme d'un argument int renvoie un ListIterator positionné à l'index spécifié. L'indice fait référence à l'élément qui serait renvoyé par un appel initial à côté. Un premier appel à précédente reviendrait l'élément dont l'indice est l'indice-1. Dans une liste de longueur n. il y a n + 1 valeurs valides pour index. de 0 à n. compris.
parlant Intuitivement, le curseur est toujours entre deux éléments # 151; celui qui serait renvoyé par un appel à précédent et celui qui serait renvoyé par un appel à la prochaine. Les n + 1 valeurs d'index valides correspondent aux écarts de n + 1 entre les éléments, à partir de l'espace avant du premier élément à l'écart après la dernière. La figure suivante montre les cinq positions de curseur possibles dans une liste contenant quatre éléments.
Les cinq positions de curseur possibles.
Les appels à suivant et précédent peuvent être entremêlés, mais vous devez être prudent. Le premier appel à des déclarations antérieures du même élément que le dernier appel à la prochaine. De même, le premier appel à côté après une séquence d'appels à des déclarations antérieures du même élément que le dernier appel au précédent.
Il ne faut donc pas surprenant que la méthode nextIndex renvoie l'index de l'élément qui serait renvoyé par un appel ultérieur à la prochaine. et previousIndex renvoie l'index de l'élément qui serait renvoyé par un appel ultérieur au précédent. Ces appels sont généralement utilisés soit pour signaler la position où quelque chose a été trouvé ou d'enregistrer la position du ListIterator pour qu'un autre ListIterator avec position identique peut être créé.
Il devrait aussi venir pas surprenant que le nombre retourné par nextIndex est toujours un plus grand que le nombre retourné par previousIndex. Ceci implique le comportement des deux cas limites: (1) un appel à previousIndex lorsque le curseur est avant l'élément initial renvoie -1 et (2) un appel à nextIndex lorsque le curseur se trouve après le dernier élément renvoie list.size () . Pour tout ce béton, ce qui suit est une mise en œuvre possible de List.indexOf.
Notez que la méthode indexOf retourne it.previousIndex (), même si elle parcourt la liste vers l'avant. La raison est que it.nextIndex () retournerait l'indice de l'élément que nous allons examiner, et nous voulons revenir l'index de l'élément que nous venons d'examiner.
L'interface Iterator fournit l'opération de suppression pour supprimer le dernier élément renvoyé par côté de la collection. Pour ListIterator. cette opération supprime le dernier élément renvoyé par suivant ou précédent. L'interface ListIterator propose deux opérations supplémentaires pour modifier la liste # 151; définir et ajouter. Le procédé de réglage remplace le dernier élément renvoyé par suivante ou précédente avec l'élément spécifié. L'algorithme polymorphe suivant utilise ensemble pour remplacer toutes les occurrences d'une valeur spécifiée par un autre.
Le seul peu de rouerie dans cet exemple est le test d'égalité entre val et it.next. Vous devez cas particulier une valeur val de null pour éviter une NullPointerException.
La méthode add insère un nouvel élément dans la liste immédiatement avant la position du curseur. Ce procédé est illustré dans l'algorithme polymorphe suivant pour remplacer toutes les occurrences d'une valeur spécifiée de la séquence de valeurs contenues dans la liste indiquée.
Range-View Opération
L'opération de distance-vue, subList (int fromIndex, int toIndex). retourne une vue de la liste de la partie de cette liste dont les indices vont de fromIndex. y compris, à toIndex. exclusif. Cette gamme de semi-ouverte reflète la caractéristique de boucle.
Comme le point de vue à long terme l'indique, la liste renvoyée est sauvegardé par la liste sur laquelle subList a été appelé, si des changements dans l'ancien se reflètent dans ce dernier.
Cette méthode élimine le besoin pour les opérations de portée explicite (du genre qui existent généralement pour les tableaux). Toute opération qui attend une liste peut être utilisée comme une opération de plage en passant une vue subList au lieu d'une liste complète. Par exemple, l'idiome suivant supprime une série d'éléments d'une liste.
idiomes similaires peuvent être construits pour rechercher un élément dans une plage.
On notera que les expressions précédentes renvoient l'index de l'élément trouvé dans la sous-liste. pas l'index dans la liste de support.
Tout algorithme polymorphes qui fonctionne sur une liste. comme les remplacer et shuffle exemples, fonctionne avec la liste retournée par subList.
L'exécution du programme produit la sortie suivante.
Bien que l'opération de subList est extrêmement puissant, certaines précautions doivent être prises lors de son utilisation. La sémantique de la liste renvoyée par subList deviennent indéfini si des éléments sont ajoutés ou supprimés de la liste d'appui d'une autre manière que par l'intermédiaire de la liste renvoyée. Ainsi, il est fortement recommandé d'utiliser la liste retournée par subList seulement comme un objet transitoire # 151; à effectuer une ou une séquence d'opérations de plage sur la Liste de support. Plus vous utilisez l'instance subList, plus la probabilité que vous compromettez en modifiant la liste de support directement ou par un autre objet subList. Notez qu'il est légal de modifier une sous-liste d'un sous-liste et de continuer à utiliser la sous-liste originale (mais pas en même temps).
Liste des algorithmes
- Trier # 151; trie une liste en utilisant un algorithme de tri de fusion, qui fournit une sorte rapide, stable. (Une sorte stable est celui qui ne réorganise pas des éléments identiques).
- battage # 151; permute au hasard les éléments d'une liste.
- sens inverse # 151; inverse l'ordre des éléments dans une liste.
- tourner # 151; tourne tous les éléments d'une liste par une distance spécifiée.
- échanger # 151; permute les éléments à des positions spécifiées dans une liste.
- remplace tout # 151; remplace toutes les occurrences d'une valeur spécifiée par un autre.
- remplir # 151; chaque élément remplace une liste avec la valeur spécifiée.
- copie # 151; copie la liste des sources dans la liste des destinataires.
- recherche binaire # 151; recherche un élément dans une liste ordonnée en utilisant l'algorithme de recherche binaire.
- indexOfSubList # 151; renvoie l'index de la première sous-liste d'une liste qui est égal à un autre.
- lastIndexOfSubList # 151; renvoie l'index de la dernière sous-liste d'une liste qui est égal à un autre.
Votre utilisation de cette page et tout le matériel sur les pages sous la bannière « Les tutoriels Java » est soumis à ces avis juridiques.