!    The following file gives the list of some Java methods and their
!!   corresponding interfaces and abstract classes in the package java.util.
!!!  For more details, please read the API documentation (JDK 1.6).
!!!! (c) ~/2a env. ~ Permanent update: 08.10.2007 17h11 / H. Nguyen-Phu
!!!! Collection; Cloneable; Deque; Iterable; Iterator; List; ListIterator;

!!!! Map;

!!!!! AbstractCollection; AbstractList; AbstractMap; AbstractQueue;

!!!!! AbstractSequentialList; AbstractSet; Calendar

!!!!! ---------------------------------------------------------------------------

Signatures des méthodes /Interfaces Remarques. ~ Profil;

Abstract classes

Collection<E> : public interface Collection<E> extends Iterable<E>

add(O) /Collection ajoute un objet ‘O’ à la collection. ~ boolean add(E o);

addAll(Collection) /Collection ajoute un ensemble d’objets. ~ boolean addAll(Collection<? extends E> c );

clear() /Collection supprime toutes les réservations de places. ~ void clear();

contains(O) /Collection vérifie l'appartenance de 'O'. ~ boolean contains(Object o);

containsAll(c) /Collection vérifie l'appartenance d'une suite d'objets. ~ boolean containsAll( Collection<?> c);

isEmpty() /Collection vérifie si l’objet courant est vide. ~ boolean isEmpty();

equals(Object o) /Collection vérifie si ‘o’ est égal à l’objet courant. ~ boolean equals(Object o);

hashCode() /Collection retourne le code de hachage de l’objet courant. ~ int hashCode();

iterator() /Collection renvoie un itérateur. ~ Iterator<E> iterator();

remove(Object) /Collection enlève la place occupée par l'objet 'Object'. ~ boolean remove(Object o);

removeAll(Collection) /Collection enlève toutes les places occupées par une collection donnée en entrée. ~ boolean removeAll( Collection<?> c );

retainAll(Collection) /Collection ne garde que les places occupées par une collection donnée en entrée. ~ boolean retainAll( Collection<?> c );

size() /Collection donne le nombre total de places occupées. ~ int size();

toArray() /Collection retourne un tableau à partir de l’instance courante. ~ Object[] toArray();

toArray(T[] a) /Collection retourne un tableau à partir du tableau ‘a’. ~ <T> T[] toArray(T[] a);

Deque<E> : public interface Deque<E> extends Queue<E> (cf. JDK 1.6)

add(elt) /Deque ajoute ‘elt’ en queue (à la fin) de la dèque courante en tant que file d’attente. ~ boolean add(E elt);

addFirst(elt) /Deque ajoute ‘elt’ au début de la dèque courante en respectant la restriction de la capacité actuelle. ~ void addFirst(E elt);

addLast(elt) /Deque ajoute ‘elt’ à la fin de la dèque courante en respectant la restriction de la capacité actuelle. ~ void addLast(E elt);

contains(obj) /Deque renvoie VRAI si cette dèque contient ‘obj’. ~ boolean contains(Object obj);

descendingIterator() /Deque renvoie un itérateur dans le sens séquentiel inversé (i.e. de la fin vers le début) pour la dèque courante. ~ Iterator<E> descendingIterator();

element() /Deque retourne, mais n’efface pas, la tête de la file représentée par cette dèque (i.e. le premier élément de la dèque). ~ E element();

getFirst() /Deque retourne, mais n’efface pas, le premier élément de cette dèque. ~ E getFirst();

getLast() /Deque retourne, mais n’efface pas, le dernier élément de cette dèque. ~ E getLast();

iterator() /Deque renvoie un itérateur dans le sens séquentiel normal (i.e. du début vers la fin) pour la dèque courante. ~ Iterator<E> iterator();

offer(E e) /Deque ajoute l’élément ‘e’ en tant que le (nouveau) dernier élément dans la dèque courante tout en retournant VRAI si succès (i.e. capacité encore suffisante) et FAUX sinon. ~ boolean offer(E e);

offerFirst(E e) /Deque ajoute l’élément ‘e’ comme le (nouveau) premier élément dans la dèque courante si la capacité est encore suffisante. ~ boolean offerFirst(E e);

offerLast(E e) /Deque ajoute l’élément ‘e’ comme le (nouveau) dernier élément dans la dèque courante si la capacité est encore suffisante. ~ boolean offerLast(E e);

peek() /Deque renvoie, mais n’efface pas, le premier élément de la dèque courante en tant que file d’attente ou renvoie ‘null’ si elle est vide. ~ E peek();

peekFirst() /Deque renvoie, mais n’efface pas, le premier élément de la dèque courante ou renvoie ‘null’ si elle est vide. ~ E peekFirst();

peekLast() /Deque renvoie, mais n’efface pas, le dernier élément de la dèque courante ou renvoie ‘null’ si elle est vide. ~ E peekLast();

poll() /Deque renvoie et efface le premier élément de la dèque courante en tant que file d’attente ou renvoie ‘null’ si elle est vide. ~ E poll();

pollFirst() /Deque renvoie et efface le premier élément de la dèque courante ou renvoie ‘null’ si elle est vide. ~ E pollFirst();

pollLast() /Deque renvoie et efface le dernier élément de la dèque courante ou renvoie ‘null’ si elle est vide. ~ E pollLast();

pop() /Deque dépile le sommet (i.e. premier élément ici) de la pile représentée par la dèque courante et le retourne. Elle est équivalente à ‘removeFirst()’. ~ E pop();

push(elt) /Deque empile l’élément ‘elt’ au sommet de la pile représentée par la dèque courante. Elle est équivalente à ‘addFirst()’. ~ void push(E item);

remove() /Deque renvoie en effaçant la tête de la file représentée par la dèque courante (i.e. premier élément ici). ~ E remove();

remove(o) /Deque supprime la première occurrence de ‘o’ de la dèque courante (<=> removeFirstOccurrence(Object)); ~ boolean remove(Object o);

removeFirst() /Deque retourne en supprimant le premier élément de la dèque courante. ~ E removeFirst();

removeFirstOccurrence(o) /Deque supprime la première occurrence de l’objet ‘o’. ~ boolean removeFirstOccurrence(Object O);

removeLast() /Deque retourne en supprimant le dernier élément de la dèque courante. ~ E removeLast();

removeLastOccurrence(o) /Deque supprime la dernière occurrence de l’objet ‘o’. ~ boolean removeLastOccurrence(Object o);

size() /Deque renvoie la taille (nombre d’éléments) de l’instance ‘Deque’ courante. ~ int size();

Iterator : public interface Iterator<E>

hasNext() /Iterator retourne ‘true’ si l’élément suivant dans la collection est présent et ‘false’ sinon. ~ boolean hasNext();

next() /Iterator retourne l’élément ‘<E>’ suivant de la collection courante. Profil (Java 5.0): E next();

remove() /Iterator supprime l’élément retourné par ‘next()’ de la collection courante. ~ void remove();

List<E> : public interface List<E> extends Collection<E>

add(elt) /List insère ‘elt’ à la fin de cette liste (opération optionnelle). ~ boolean add(E o);

add(i, elt) /List insère 'elt' à la liste courante en position ‘i’. ~ void add(int i, E elt);

addAll(coll) /List ajoute en queue tous les éléments de la collection 'coll' à la liste courante. ~ boolean addAll(Collection<? extends E> c);

addAll(i, coll) /List ajoute en position ‘i’ tous les éléments de la collection 'coll' à la liste courante. ~ boolean addAll(int i, Collection<? extends E> c);

clear() /List efface tous les éléments de cette liste. ~ void clear();

contains(O) /List teste si cette liste contient l’objet ‘Obj’. ~ boolean contains(Object O);

containsAll(coll) /List teste si cette liste contient tous les éléments de la collection ‘coll’. ~ boolean containsAll(Collection<?> coll);

equals(obj) /List teste si cette liste est égale à l’objet spécifié ‘obj’. ~ boolean equals(Object o)

get(i) /List renvoie l’élément en position ‘i’ dans cette liste. ~ E get(int i);

hashCode() /List renvoie la valeur du code de hachage pour cette liste. ~ int hashCode();

indexOf(o) /List renvoie l’index de la première occurrence de l’élément spécifié dans cette liste, ou -1 si absence. ~ int indexOf(Object o);

isEmpty() /List retourne VRAI si cette liste ne contient pas d’éléments. ~boolean isEmpty();

iterator() /List renvoie un itérateur dans le sens séquentiel normal (i.e. du début vers la fin) pour cette liste. ~ Iterator<E> iterator();

lastIndexOf(o) /List renvoie l’index de la dernière occurrence de l’élément spécifié dans cette liste, ou -1 si absence. ~ int lastIndexOf(Object o).

listIterator() /List retourne un itérateur des éléments de la liste courante. ~ ListIterator<E> listIterator();

listIterator(i) /List retourne un itérateur des éléments de la liste courante partant de la position ‘i’. ~ ListIterator<E> listIterator(int i).

remove(i) /List efface l’élément en position ‘i’ dans cette liste (opération optionnelle). ~ E remove(int i);

remove(o) /List supprime la première occurrence de ‘o’ dans cette liste, si ‘o’ est présent (opération optionnelle). ~ boolean remove(Object o);

removeAll(c) /List supprime tous les éléments de la collection ‘c’ contenue dans cette liste (opération optionnelle). ~ boolean removeAll(Collection<?> c);

retainAll(c) /List ne conserve que les éléments dans cette liste s’ils sont contenus dans la collection donnée en entrée. ~ boolean retainAll(Collection<?> c);

set(i, elt) /List remplace l’élément en position ‘i’ par ‘elt’ dans cette liste et renvoie l’ancien composant. ~ E set(int i, E elt);

size() /List renvoie la taille (nombre d’éléments) de cette liste. ~ int size();

subList(deb, fin) /List renvoie une partie des éléments du rang ‘deb’ inclus au rang ‘fin’ exclus de cette liste. ~ List<E> subList(int deb, int fin);

toArray() /List renvoie un tableau contenant tous les composants dans cette liste. ~ Object[] toArray();

toArray(T[] a) /List renvoie un tableau contenant tous les composants de cette liste; le type du tableau retourné est spécifié par celui de l’argument lors de l’exécution. ~ <T> T[] toArray(T[] a);

 
 
ListIterator<E> : public interface ListIterator<E> extends Iterator<E>

add(elt) /ListIterator insère ‘elt’ juste AVANT l’élément suivant qui serait fourni par ‘next()’ ou juste APRES l’élément précédent qui proviendrait de ‘previous()’. ~ void add(E o);

hasNext() /ListIterator retourne ‘true’ si l’élément suivant dans la collection est présent et ‘false’ sinon. ~ boolean hasNext();

hasPrevious() /ListIterator retourne ‘true’ si l’élément précédent dans la collection est présent et ‘false’ sinon. ~ boolean hasPrevious();

next() /ListIterator retourne l’élément ‘<E>’ suivant de la collection courante. ~ E next();

nextIndex() /ListIterator retourne l’indice de l’élément ‘<E>’ suivant. ~ int nextIndex();

previous() /ListIterator retourne l’élément ‘<E>’ précédent de la collection courante. ~ E previous();

previousIndex() /ListIterator retourne l’indice de l’élément ‘<E>’ précédent. ~ int previousIndex();

remove() /ListIterator supprime l’élément retourné par ‘next()’. ~ void remove();

set(elt) /ListIterator remplace le dernier élément retourné par ‘next’ ou ‘previous’ par « elt ». ~ void set(E o);

Map<Key, Value> : public interface Map<K, V>

clear() /Map supprime tous les objets de l’instance ‘Map’ courante. ~  void clear();

containsKey(Object) /Map teste si l’instance ‘Map’ courante contient l’élément ayant pour clé de type ‘Object’. ~ boolean containsKey(Object clé);

containsValue(Val) /Map teste si l’instance ‘Map’ courante contient ‘Val’ de type ‘Object’. ~ boolean containsValue(Object valeur);

entrySet() /Map renvoie une vue d’ensemble ‘Set’ de couples d’objets de l’instance courante. ~ Set<Map.Entry<K,V>> entrySet();

equals(Object) /Map test d’égalité entre l’objet ‘o’ avec l’instance ‘Map’ courante. ~ boolean equals(Object o);

get(Object) /Map renvoie un objet de l’instance ‘Map’ courante ayant pour clé de type ‘Object’ ou null si non appartenance. ~ V get(Object key);

hashCode()  /Map renvoie le code de hachage de l’objet ‘Map’ courant. ~ int hashCode();

isEmpty() /Map teste si l’objet ‘Map’ ne contient aucun élément. ~ boolean isEmpty();

keySet() /Map renvoie une vue d’ensemble ‘Set’ de clés. ~ Set<K> keySet();

put(Key, Value) /Map modifie l’élément ayant pour clé ‘Key’ avec la nouvelle valeur ‘Value’ (opération optionnelle). ~ V put(K clé, V valeur);

putAll(Map) /Map copie toute la table ‘Map’ dans l’instance courante (opération optionnelle). ~ void putAll(Map< ? extends K, ? extends V> m);

remove(Key) /Map retire l’élément ayant pour clé ‘Key’ de l’instance ‘Map’ courante (opération optionnelle). V remove(Object key);

size() /Map donne le nombre total de couples « clé-valeur » de l’instance ‘Map’ courante. ~ int size();

values() /Map renvoie un objet ‘Collection’ de valeurs de type ‘V’. ~ Collection<V> values();

AbstractCollection<E> : public abstract class AbstractCollection<E> implements Collection<E> (cf. JDK 1.2 ...)

protected

AbstractCollection()           Sole constructor.

Method Summary
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	isEmpty()           Returns true if this collection contains no elements.
abstract  Iterator<E>	iterator()           Returns an iterator over the elements contained 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 of 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).
abstract  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)           Returns an array containing all of the elements in this collection; the runtime type of the returned array is that of the specified array.
String	toString()           Returns a string representation of this collection.

AbstractList<E> : public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> (cf. JDK 1.2 ...)

protected

AbstractList()           Sole constructor.

Method Summary
boolean	add(E e)           Appends the specified element to the end of this list (optional operation).
void	add(int index, E element)           Inserts the specified element at the specified position in this list (optional operation).
boolean	addAll(int index, Collection<? extends E> c)           Inserts all of the elements in the specified collection into this list at the specified position (optional operation).
void	clear()           Removes all of the elements from this list (optional operation).
boolean	equals(Object o)           Compares the specified object with this list for equality.
abstract  E	get(int index)           Returns the element at the specified position in this list.
int	hashCode()           Returns the hash code value for this list.
int	indexOf(Object o)           Returns the index of the first occurrence of the specified element in this list, or -1 if this list does not contain the element.
Iterator<E>	iterator()           Returns an iterator over the elements in this list in proper sequence.
int	lastIndexOf(Object o)           Returns the index of the last occurrence of the specified element in this list, or -1 if this list does not contain the element.
ListIterator<E>	listIterator()           Returns a list iterator over the elements in this list (in proper sequence).
ListIterator<E>	listIterator(int index)           Returns a list iterator of the elements in this list (in proper sequence), starting at the specified position in this list.
E	remove(int index)           Removes the element at the specified position in this list (optional operation).
protected  void	removeRange(int fromIndex, int toIndex)           Removes from this list all of the elements whose index is between fromIndex, inclusive, and toIndex, exclusive.
E	set(int index, E element)           Replaces the element at the specified position in this list with the specified element (optional operation).
List<E>	subList(int fromIndex, int toIndex)           Returns a view of the portion of this list between the specified fromIndex, inclusive, and toIndex, exclusive.

AbstractMap<K,V> : public abstract class AbstractMap<K,V> implements Map<K,V> (cf. JDK 1.2 ...)

Nested Class Summary
static class	AbstractMap.SimpleEntry<K,V>           An Entry maintaining a key and a value.
static class	AbstractMap.SimpleImmutableEntry<K,V>           An Entry maintaining an immutable key and value.

Nested classes/interfaces inherited from interface java.util.Map

Map.Entry<K,V>

Constructor Summary
protected	AbstractMap()           Sole constructor.

Method Summary
void	clear()           Removes all of the mappings from this map (optional operation).
protected  Object	clone()           Returns a shallow copy of this AbstractMap instance: the keys and values themselves are not cloned.
boolean	containsKey(Object key)           Returns true if this map contains a mapping for the specified key.
boolean	containsValue(Object value)           Returns true if this map maps one or more keys to the specified value.
abstract  Set<Map.Entry <K,V>>	entrySet()           Returns a Set view of the mappings contained in this map.
boolean	equals(Object o)           Compares the specified object with this map for equality.
V	get(Object key)           Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key.
int	hashCode()           Returns the hash code value for this map.
boolean	isEmpty()           Returns true if this map contains no key-value mappings.
Set<K>	keySet()           Returns a Set view of the keys contained in this map.
V	put(K key, V value)           Associates the specified value with the specified key in this map (optional operation).
void	putAll(Map<? extends K,? extends V> m)           Copies all of the mappings from the specified map to this map (optional operation).
V	remove(Object key)           Removes the mapping for a key from this map if it is present (optional operation).
int	size()           Returns the number of key-value mappings in this map.
String	toString()           Returns a string representation of this map.
Collection<V>	values()           Returns a Collection view of the values contained in this map.

AbstractQueue<E> : public abstract class AbstractQueue<E> extends AbstractCollection<E> implements Queue<E> (cf. JDK 1.5)

protected

AbstractQueue()           Constructor for use by subclasses.

Method Summary
boolean	add(E e)           Inserts the specified element into this queue if it is possible to do so immediately without violating capacity restrictions, returning true upon success and throwing an IllegalStateException if no space is currently available.
boolean	addAll(Collection<? extends E> c)           Adds all of the elements in the specified collection to this queue.
void	clear()           Removes all of the elements from this queue.
E	element()           Retrieves, but does not remove, the head of this queue.
E	remove()           Retrieves and removes the head of this queue.

AbstractSequentialList<E> : public abstract class AbstractSequentialList<E> extends AbstractList<E> (cf. JDK 1.2)

protected

AbstractSequentialList()           Sole constructor.

Method Summary
void	add(int index, E element)           Inserts the specified element at the specified position in this list (optional operation).
boolean	addAll(int index, Collection<? extends E> c)           Inserts all of the elements in the specified collection into this list at the specified position (optional operation).
E	get(int index)           Returns the element at the specified position in this list.
Iterator<E>	iterator()           Returns an iterator over the elements in this list (in proper sequence).
abstract  ListIterator<E>	listIterator(int index)           Returns a list iterator over the elements in this list (in proper sequence).
E	remove(int index)           Removes the element at the specified position in this list (optional operation).
E	set(int index, E element)           Replaces the element at the specified position in this list with the specified element (optional operation).

AbstractSet<E> : public abstract class AbstractSet<E> extends AbstractCollection<E> implements Set<E> (cf. JDK 1.2)

AbstractSet() AbstractSet constructeur sans arguments. # AbstractSet();

equals(O) AbstractSet test d’égalité entre l’objet ‘O’ avec cet ensemble (i.e. instance courante). ~ boolean equals(Object o);

hashCode() AbstractSet renvoie la valeur du code de hachage pour cet ensemble. ~ int hashCode();

removeAll(c) AbstractSet enlève toutes les places occupées par une collection donnée en entrée de cet ensemble (opération optionnelle). ~ boolean removeAll( Collection<?> c );

Calendar : public abstract class Calendar implements Serializable, Cloneable, Comparable<Calendar>

Calendar() Calendar constructeur sans arguments
getInstance() Calendar récupère une instance d'un objet 'Calendar' initialisée avec la date et l'heure courante.

setTime(Date) Calendar  affecte à un objet 'Calendar' la valeur d'un objet 'Date'.
get(int) Calendar  extrait la valeur d'un champ d'un objet 'Calendar'. Ex.:  get(Calendar.YEAR)
set(int,int,int) Calendar  affecte à un objet 'Calendar' la valeur du premier argument comme année, la valeur du 2nd comme mois, la valeur du 3è comme jour.

set(a1,a2,a3,a4,a5) Calendar affecte comme précédemment avec la valeur du 4è comme heure, la valeur du 5è argument 'int' comme minute.