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: L'interface Collection(java.lang)

____________________________________________________________________________________________________

Connexion

Les collections - L'interface Collection(java.util)

Sommaire :

I) Le framework de collections de Java( "The Java Collections Framework")
I-1) Les six interfaces du framework de collections
II) Généralités sur l'interface Collection( java.util)
III) L'interface Iterable<T> (java.lang)
IV) L'interface Iterator<T> (java.util)
V) Les méthodes de l'interface Collection( java.util)

I) Le framework de collections de Java( "The Java Collections Framework")

Dès la première version de java, le jdk 1.0, des classes de collections existaient, qui sont HashTable, Vector, Enumeration, et Properties.
Le framework de collections est apparu à la version 1.2 du jdk, c'est une API qui permet ,grâce aux interfaces fournies, de définir nos propres classes de collections. Les anciennes classes, antérieures au jdk 1.2, ont été adaptées et ajoutées à ce framework.

I-1) Les six interfaces du framework de collections:

Les six interfaces du framework des collections sont Collection, Set, List, Map, SortedSet, SortedMap.

II) Généralités sur l'interface Collection( java.util)

On peut résumer en disant que Collection est l'interface de base pour les collections. Elle représente un ensemble d'objets( ordonnés ou pas), avec des objets pouvant être en doublons. La collection peut permettre ou pas l'ajout ou la suppression d'éléments.
C'est donc une généralisation maximale de la notion de collection, car le minimum de contraintes est demandé. La seule contrainte est d'avoir un ensemble d'objets.

III) L'interface Iterable<T> (java.lang)

Cette interface a une méthode, iterator(), qui fournit un itérateur.
Elle permet donc de certifier que la classe est itérable.

IV) L'interface Iterator<T> (java.util)

package java.util;

/**
 * An iterator over a collection.  Iterator takes the place of Enumeration in
 * the Java collections framework.  Iterators differ from enumerations in two
 * ways: <ul>
 *	<li> Iterators allow the caller to remove elements from the
 *	     underlying collection during the iteration with well-defined
 * 	     semantics.
 *	<li> Method names have been improved.
 * </ul><p>
 *
 * This interface is a member of the 
 * <a href="{@docRoot}/../technotes/guides/collections/index.html">
 * Java Collections Framework</a>.
 *
 * @author  Josh Bloch
 * @version 1.27, 07/24/06
 * @see Collection
 * @see ListIterator
 * @see Enumeration
 * @since 1.2
 */
public interface Iterator<E> {
    /**
     * Returns <tt>true</tt> if the iteration has more elements. (In other
     * words, returns <tt>true</tt> if <tt>next</tt> would return an element
     * rather than throwing an exception.)
     *
     * @return <tt>true</tt> if the iterator has more elements.
     */
    boolean hasNext();

/**
     * Returns the next element in the iteration.
     *
     * @return the next element in the iteration.
     * @exception NoSuchElementException iteration has no more elements.
     */
    E next();

/**
     * 
     * Removes from the underlying collection the last element returned by the
     * iterator (optional operation).  This method can be called only once per
     * call to <tt>next</tt>.  The behavior of an iterator is unspecified if
     * the underlying collection is modified while the iteration is in
     * progress in any way other than by calling this method.
     *
     * @exception UnsupportedOperationException if the <tt>remove</tt>
     *		  operation is not supported by this Iterator.
     
     * @exception IllegalStateException if the <tt>next</tt> method has not
     *		  yet been called, or the <tt>remove</tt> method has already
     *		  been called after the last call to the <tt>next</tt>
     *		  method.
     */
    void remove();
}

Un itérateur représente un itérateur sur une collection.
Par exemple, l'itérateur pour Collection<E> est un Iterator<E>.
Il possède trois méthodes. La méthode next() qui retourne un objet de type E.
La méthode remove(), qui supprime de la collection sous-jacente le dernier élément retourné par l'itérateur( c'est à dire l'élément courant de l'itérateur).
Les collections non modifiables ne sont pas obligées de supporter cette méthode: dans ce cas, elle ne fait que déclencher une UnsupportedOperationException.
Enfin la méthode boolénne hasNext(), retourne vrai s'il y a un suivant, false sinon.
Remarque: un itérateur ne concerne pas forcément une collection ordonnée( la preuve en est d'ailleurs que Collection implémente cette interface).

On s'aperçoit qu'un itérateur est un interfaçage vers une collection sous-jacente, mais ce n'est pas lui-même une collection.

En regardant une implémentation de Iterator, qu'on peut trouver dans AbstractList (java.util), on voit qu'il a été choisi une classe(private) interne non statique. C'est à dire que chaque objet Iterator nécessitera un objet AbstractList pour pouvoir être instancié, et aura accès à tous ses attributs et méthodes. L'objet Iterator aura ici accès aux méthodes d'obtention d'un élément de la collection.

V) Les méthodes de l'interface Collection( java.util)

Rappel: Les méthodes sont toutes les primitives de base qu'on pourrait imaginer pour un ensemble d'objets correspondant à la définition vue ci-dessus d'une collection.

Regardons la liste des méthodes, pour une Collection<E>:

boolean add(E e) 
          Ensures that this collection contains the specified element (optional operation). 
 boolean addAll(Collection<? extends E> c) 
          Adds all of the elements in the specified collection to this collection (optional operation). 
 void clear() 
          Removes all of the elements from this collection (optional operation). 
 boolean contains(Object o) 
          Returns true if this collection contains the specified element. 
 boolean containsAll(Collection c) 
          Returns true if this collection contains all of the elements in the specified collection. 
 boolean equals(Object o) 
          Compares the specified object with this collection for equality. 
 int hashCode() 
          Returns the hash code value for this collection. 
 boolean isEmpty() 
          Returns true if this collection contains no elements. 
 Iterator iterator() 
          Returns an iterator over the elements in this collection. 
 boolean remove(Object o) 
          Removes a single instance of the specified element from this collection, if it is present (optional operation). 
 boolean removeAll(Collection<?> c) 
          Removes all this collection's elements that are also contained in the specified collection (optional operation). 
 boolean retainAll(Collection<?> c) 
          Retains only the elements in this collection that are contained in the specified collection (optional operation). 
 int size() 
          Returns the number of elements in this collection. 
 Object[] toArray() 
          Returns an array containing all of the elements in this collection.
		  
 <T> T[] toArray(T[] a) (pour une collection<E>)
          Returns an array containing all of the elements in this collection; the runtime type of the returned array
		 is that of the specified array.

Les méthodes d'ajout et de suppression sont optionnelles, selon que la collection supporte ou non l'ajout et la suppression. Si la collection ne supporte pas une des opérations, la méthode déclenchera une UnsupportedOperationException(java.lang).
Retourne le nombre d'éléments de la collection.
Retourne un tableau contenant tous les éléments de la collection. On remarque que ce n'est pas un tableau de E, mais un tableau d'Object. Retourne, dans le tableau passé en paramètre, tous les éléments de la collection. Si ce tableau n'est pas assez grand, crée un nouveau tableau, du même type que celui passé en paramètre.
Appeler toArray(newObject(0)), va retourner un nouveau tableau, et de type Object comme celui en paramètre, et par conséquent c'est comme un appel à toArray().
Retourne true si cette collection ne contient aucun élément.
Retourne true si la collection contient l'élément spécifié. A noter que le paramètre n'est pas de type <E>, mais Object. Ceci limite les contraintes.
Retourne true si la collection contient tous les éléments de la collection passée en paramètre. Cela ne signifie pas qu'elle ne peut pas avoir d'éléments supplémentaires, bien sûr.
hashcode(): classique.
Retourne true si l'objet spécifié est égal à la collection. Si on ne la redéfinit pas, on utilisera le equals de la classe Object, qui compare les références. On pourra choisir de redéfinir equals, et d'effectuer une comparaison en terme de valeurs. Par exemple, la méthode equals de l'interface (java.util).List<E>( qui étend Collection<E>) pose comme première condition que le paramètre soit une List, et si les deux listes contiennent les mêmes éléments et dans le même ordre.
Retourne un itérateur sur les éléments de la collection.

Le reste des méthodes sont optionnelles, elles concernent l'ajout et la suppression dans la liste, qui peuvent ne pas être autorisés. Si la collection ne supporte pas une des opérations, la méthode déclenchera une UnsupportedOperationException(java.lang).
Vérifie d'abord que la collection ne contient pas l'élément(optionnel, si la collection ne supporte pas les doublons). Ajoute l'élément e a la collection. Retourne true si la collection a changé. Retourne false si l'élément n'a pu être ajouté car il était déjà présent. Certaines collections peuvent refuser d'ajouter certains éléments, comme null. Dans ce cas, elles ne doivent pas retourner false, mais déclencher une exception.
Cela préserve l'invariant qui est qu'une collection possède toujours l'élément après le retour de la méthode.
Ajoute tous les éléments de la collection spécifiée, à la collection. Le comportement de cette méthode est indéfini si la collection spécifiée est modifiée pendant le déroulement de l'opération. Notez que c'est le cas lorsque la collection spécifiée est cette collection(et que cette collection est non vide).
Efface tous les éléments de la collection. La collection sera vide après le retour, ou alors il y aura une exception.
Supprime une instance de o, si la collection contient une ou plusieurs instance de o. Retourne true si la collection a changé( c'est à dire si la collection contenait au moins une instance de o).
Supprime tous les éléments de la collection spécifiée, qui se trouvent dans notre collection. Après le retour, la collection ne contient plus aucun élément contenus dans la collection spécifiée.
Garde uniquement les éléments de la collection spécifiée, qui se trouvent dans notre collection. Cela signifie qu'elle supprime tous les éléments qui ne font pas partie de la collection spécifiée.
Retourne true si la collection a changé.

RETOUR HAUT