www.infkoffler.com - Site de cours d'informatique

Accueil

Java Standard Edition

Java EE 5

Visual Basic .Net 2005

Cours Javascript - DOM - DHTML

Nouveautés sur le site

Contacts

Accueil > Java Standard Edition > Les collections(2): L'interface List(java.util)

____________________________________________________________________________________________________

Connexion

Les collections(2): L'interface List(java.util)

Sommaire :

I) Généralités
II) Les méthodes de List (java.util)
III) L'interface ListIterator(java.util)

I) Généralités

"An ordered collection (also known as a sequence). The user of this interface has precise control over where in the list each element is inserted. The user can access elements by their integer index (position in the list), and search for elements in the list.

Unlike sets, lists typically allow duplicate elements. More formally, lists typically allow pairs of elements e1 and e2 such that e1.equals(e2), and they typically allow multiple null elements if they allow null elements at all. It is not inconceivable that someone might wish to implement a list that prohibits duplicates, by throwing runtime exceptions when the user attempts to insert them, but we expect this usage to be rare."

Traduction personnelle sommaire:

Une collection ordonnée( aussi appelée séquence). L'utilisateur de cette interface a le contrôle précis de où, dans la liste, chaque élément est inséré. L'utilisateur peut accéder aux éléments par leur index entier( position dans la liste), et rechercher des éléments dans la liste.

Au contraire des Sets, les listes permettent typiquement les doublons. Plus formellement, les listes permettent typiquement des paires d'éléments e1 et e2 tel que e1.equals(e2), et elles permettent typiquement de multiples éléments null( si elles autorisent l'élément null). Ce n'est pas inconcevable que quelqu'un peut souhaiter implémenter une liste qui ne permet pas les doublons, en déclenchant des exceptions à l'exécution quand l'utilisateur essaye de les insérer, mais nous espérons que cet usage reste rare.

Fin traduction

List est d'abord un type de Collection( car elle étend l'interface Collection), et elle est générique. Elle apporte des exigences, en ce qui concerne l'accès direct à un élément de la liste( de par son numéro de place dans la liste).
Attention, "ordonné" signifie que chaque élément de la liste peut être désigné par un index, qui est sa place dans la liste. Cela ne veut pas dire que tous les éléments soient classés dans un certain ordre.
En résumé, une liste est donc caractérisée par la possibilité d'accéder à ses éléments directement par leur index dans la liste, et donc la possibilité de retenir la place d'un élément dans la liste. Cela veut dire aussi un accès direct à un endroit précis de la liste. La méthode permettant d'accèder à un index précis existe toujours(get). Mais les méthodes permettant de modifier la liste à un index précis(set), ou d'insérer un élément à un endroit précis(add) sont optionnelles.
Les listes autorisent les doublons(ce qui les différencie des Sets), mais on n'interdit pas que certaines listes interdisent les doublons( par des exceptions déclenchées).

II) Les méthodes de List (java.util)

Regardons les méthodes caractéristiques: Retourne l'élément à la position index de la liste. Déclenche IndexOutOfBoundsException(java.lang) si l'index est hors limites(<0 ou >=size() ).
Remplace l'élément à l'index spécifié, par l'élément passé en paramètre. Déclenche UnsupportedOperationException(java.lang), si cette méthode n'est pas supportée par la liste.
Remarquons que cette méthode est optionnelle, de même que add qui permet d'insérer un élément à un index précis.
Permet d'insérer l'élément à l'index voulu. Décale l'élément qui était présent auparavant à l'index, ainsi que tous les éléments suivants( ajoute 1 à leur index). Notez que cette méthode est optionnelle.
Insère tous les éléments de la liste spécifiée, dans notre liste, à partir de l'index. Décale les anciens éléments.
Les nouveaux éléments seront ajoutés dans l'ordre donné par l'iterator de la collection.
Supprime l'élément à l'index spécifié. Décale les éléments suivants vers la gauche(leur index diminue de 1).
Retourne l'élément supprimé.
Retourne l'index, dans la liste, de la première occurrence de l'élément en question. Retourne -1 s'il n'y figure pas. o peut valoir null, dans ce cas, on recherche le premier null.
Comme indexOf, mais retourne l'index de la dernière occurence.
Retourne une sous-liste de notre liste, à partir de l'index fromIndex inclus, jusqu'à l'index toIndex exclus.
La liste retournée est associée à notre liste, ce qui implique que tout changement non-structurel dans la liste retournée, se reflète dans notre liste, et réciproquement. La sous-liste supporte toutes les opérations optionnelles supportées par notre liste.
Pour mieux comprendre, prenons l'exemple de l'implémentation de cette méthode par la classe (java.util.)AbstractList(qui hérite de List). Dans ce cas, subList crée un nouvel objet de la classe SubList. Cette classe SubList n'est pas publique, et se trouve dans le même fichier que AbstractList. Elle a des attributs privés qui nous éclairent: "private AbstractList<E> l", qui est la liste mère. "private int offset", qui est l'index dans la liste mère, de début de la sous-liste, "private int size" est la taille de la sous-liste. SubList hérite de AbstractList<E>, et redéfinit un certain nombre de méthodes. Par exemple la méthode set( "public E set(int index, E element)"), qui va faire un "l.set(index+offset, element)", c'est-à-dire qui va faire un set sur la liste mère. On en conclut que pour SubList, aucune donnée de la sous-liste n'est dans l'objet sous-liste, ce sont directement les données de la liste mère.
Le sens de la sous-liste retournée par List devient indéfini, si la liste mère est modifiée dans sa structure, d'une autre façon que par la sous-liste.
Retourne un (java.util.)ListIterator<E>, sur les éléments de la liste. Nous verrons au prochain paragraphe ce qu'est un ListIterator
Retourne un (java.util.)ListIterator<E>, sur les éléments de la liste à partir de l'index spécifié.

III) L'interface ListIterator(java.util)

Outre les méthodes hasNext(), next(), et Remove(), ListIterator ajoute un certain nombre de méthodes, qui tiennent comptent des spécificités de la collection.
A noter que les méthodes de modification de la liste, set et add, sont optionnelles.
Retourne vrai si la liste a encore un élément si on la parcourt en sens inverse.
Retourne l'élément précédent de la liste. Ou déclenche l'exception NoSuchElementException(java.util), s'il n'y en a pas.
Retourne l'index de l'élément suivant(si on appelait next() ), ou la taille de la liste(size) si c'est le dernier élément.
Retourne l'index de l'élément précédent(si on appelait previous() ), ou -1 si on est au début de la liste.
Permet de remplacer la valeur de l'élément courant pour l'iterateur, c'est-à-dire l'élément obtenu après le dernier appel à next() ou à previous(). Ne pas avoir appelé remove ou add après le next() ou previous().
Retourne UnsupportedOperationException, si cette méthode n'est pas supportée.
Insère l'élément spécifié, après l'élément courant(c'est-à-dire l'élément obtenu après le dernier appel à next() ou à previous() ).

RETOUR HAUT