!
The following file gives the list of some Java methods and
!! their corresponding interfaces and classes in the
package java.util.
!!! For more details, please read the API documentation (JDK 1.6).
!!!! (c) ~/2a env. ~ Permanent update: 07.10.2007 16h38 / H.
Nguyen-Phu
!!!! Collection; Cloneable;
Deque;
Iterable; List;
ListIterator;
Map;
!!!! Serializable
!!!!! ArrayDeque; ArrayList; Arrays;
Calendar;
Collections;
LinkedList;
!!!!! PriorityQueue; Random;
Stack;
Vector
!!!!!
------------------------------------------------------------------------------
Méthodes
Classes/Interfaces
Remarques. – Profil
Collection : public interface Collection<E>
extends Iterable<E>
add(Object) /Collection ajoute un objet à 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(Collection) /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 ‘null’ si elle est vide. ~ E peek();
peekFirst() /Deque renvoie, mais n’efface pas, le
premier élément de la dèque courante ou ‘null’ si elle est vide.
~ E peekFirst();
peekLast()
/Deque renvoie, mais n’efface pas, le
dernier élément de la dèque courante ou ‘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 ‘null’ si elle est vide. ~ E poll();
pollFirst() /Deque renvoie et efface le
premier élément de la dèque courante ou ‘null’ si elle est vide.
~ E pollFirst();
pollLast()
/Deque renvoie et efface le
dernier élément de la dèque courante ou ‘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();
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 : 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 : 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();
ArrayDeque : public class ArrayDeque<E> extends AbstractCollection<E> implements Deque<E>, Cloneable, Serializable
ArrayDeque() ArrayDeque constructeur sans argu. pour contenir 16
éléments.
ArrayDeque(i_Capa) ArrayDeque
constructeur avec capacité initiale de stockage. ~ public
ArrayDeque( int numElements);
ArrayDeque(coll) ArrayDeque constructeur avec capacité initiale égale
à la taille de la collection ‘coll’. ~ public ArrayDeque(Collection<?
extends E> c);
add(O) ArrayDeque ajoute l’élément ‘O’ en queue « Adjq »
de l’instance courante. ~ public boolean
add(E o);
addFirst(O) ArrayDeque insère, dans l’objet courant, l’élément
‘O’ au début. ~ public void addFirst(E o);
addLast(O) ArrayDeque insère, dans l’objet courant, l’élément
‘O’ à la fin. ~ public void addLast(E o);
clear() ArrayDeque efface tous les éléments de l’instance
courante. ~ public void clear();
clone() ArrayDeque renvoie un clone de l’instance courante.
~ public ArrayDeque<E> clone();
contains(Obj) ArrayDeque teste si l’instance courante contient
l’objet ‘Obj’. ~ public boolean contains( Object elem);
descendingIterator()ArrayDeque renvoie un itérateur de la fin vers le début.
~ public
Iterator<E> descendingIterator();
element() ArrayDeque renvoie, mais n’efface pas, la tête de la
file représentée par cette instance. ~ public E element();
getFirst() ArrayDeque renvoie le premier
élément de l’objet courant. Elle déclenche une exception si l’instance
est vide (<> ‘peekFirst’). ~ public
E getFirst();
getLast() ArrayDeque renvoie le dernier
élément de l’objet courant. Elle déclenche une exception si l’instance
est vide (<> ‘peekLast’). ~ public
E getLast().
isEmpty() ArrayDeque teste si l’instance courante ‘ArrayDeque’
est vide. ~ public boolean isEmpty();
iterator() ArrayDeque renvoie un itérateur dans
le sens ascendant, du début vers la fin. ~ public Iterator<E> iterator();
offer(E
e) ArrayDeque ajout de l’élément spécifié comme le
(nouveau) dernier élément dans la dèque courante. ~ public
boolean offer(E e);
offerFirst(E
e) ArrayDeque ajout de l’élément spécifié comme le
(nouveau) premier élément dans la dèque courante. ~ public
boolean offerFirst(E e);
offerLast(E
e) ArrayDeque ajout de l’élément spécifié comme le (nouveau)
dernier élément dans la dèque courante. ~ public boolean
offerLast(E e);
peek() ArrayDeque renvoie le
premier élément de la dèque courante en tant que file d’attente
ou ‘null’ si elle est vide. ~ public E peek();
peekFirst() ArrayDeque renvoie le
premier élément de la dèque courante en tant que file d’attente
ou ‘null’ si elle est vide. ~ public E peekFirst();
peekLast()
ArrayDeque renvoie
le dernier élément de la dèque courante en tant que file
d’attente ou ‘null’ si elle est vide. ~ public E peekLast();
poll() ArrayDeque renvoie et
efface le premier élément de la dèque courante en tant que
file d’attente ou ‘null’ si elle est vide. ~ public E poll();
pollFirst() ArrayDeque renvoie et efface
le premier élément de la dèque courante en tant que file
d’attente ou ‘null’ si elle est vide. ~ public E pollFirst();
pollLast()
ArrayDeque renvoie
et efface le dernier élément de la dèque courante en tant que
file d’attente ou ‘null’ si elle est vide. ~ public E pollLast();
pop() ArrayDeque
dépile le sommet (i.e. premier élément) de la dèque courante (en tant que pile)
et le retourne. Elle est équivalente à ‘removeFirst()’. ~ public E pop();
push(elt) ArrayDeque empile l’élément
‘elt’ au sommet de la dèque courante (en tant que pile). Elle est équivalente à
‘addFirst()’. ~
public void push(E item);
remove()
ArrayDeque Elle est équivalente à ‘poll()’ mais
relaie l’exception ‘NoSuchElementException’
si la dèque est vide. ~ public E
remove();
remove(obj) ArrayDeque supprime une instance unique de l’élément
désigné par ‘obj’ de la dèque courante (<=> removeFirstOccurrence(java.lang.Object));
Profil : public boolean
remove(Object obj);
removeFirst() ArrayDeque Elle est équivalente à ‘pollFirst()’ mais
relaie l’exception ‘NoSuchElementException’
si la dèque est vide. ~ public E
removeFirst();
removeFirstOccurrence(O) ArrayDeque supprime la première
occurrence de l’objet O. ~ public boolean removeFirstOccurrence(Object
O);
removeLast()
ArrayDeque Elle est équivalente à ‘pollLast()’ mais
relaie l’exception ‘NoSuchElementException’
si la dèque est vide. ~ public E
removeLast();
removeLastOccurrence(O) ArrayDeque supprime la dernière
occurrence de l’objet O. ~ public boolean
removeLastOccurrence(Object O);
size() ArrayDeque donne la taille (nombre d’éléments) de
l’instance ‘ArrayDeque’ courante. ~ public int size();
toArray() ArrayDeque retourne le tableau d’objets (éléments)
correspondants à la dèque courante. ~
public Object[] toArray();
toArray(T[]
a) ArrayDeque retourne le tableau ‘a’ avec les éléments
de l’instance courante. ~ public <T> T[] toArray(T[] a);
ArrayList Nom: public class ArrayList<E> extends
AbstractList<E> implements Serializable, Cloneable, List<E>,
java.util.RandomAccess
ArrayList() ArrayList constructeur sans argument avec capacité
initiale de 10; préférer cette classe par rapport à ‘Vector’ car son
implémentation n’est pas synchronisée.
ArrayList(i_Capa) ArrayList
constructeur avec capacité initiale de stockage. ~ public ArrayList(
int initialCapacity);
ArrayList(coll) ArrayList constructeur avec capacité initiale de
110% de la taille de la collection ‘coll’. ~
public ArrayList(Collection<? extends E> c);
add(O) ArrayList ajoute l’élément ‘O’ en queue « Adjq »
de l’instance courante. ~ public boolean
add(E o);
add(i,
O) ArrayList
insère, dans l’objet courant, l’élément ‘O’ à l’indice entier ‘i’. ~
public void add(int index, E element);
addAll(Coll) ArrayList ajoute tous les éléments de ‘Coll’ à la
fin de l’objet courant. ~ public boolean addAll(Collection<? extends E>
c);
addAll(i,
Coll) ArrayList ajoute les éléments de ‘Coll’ à partir de
l’indice spécifié ‘i’ à la fin de l’objet courant. ~ public boolean addAll(int index,
Collection<? extends E> c);
clear() ArrayList efface tous les éléments de l’instance
courante. ~ public void clear();
clone() ArrayList renvoie un clone de l’instance courante.
~ public Object clone();
contains(Obj) ArrayList teste si l’instance courante contient
l’objet ‘Obj’. ~ public boolean contains( Object elem);
ensureCapacity(min) ArrayList assure la capacité minimale spécifiée par
‘min’ de l’objet courant. ~ public void ensureCapacity(int minCapacity);
get(indice) ArrayList renvoie l’élément désigné par l’indice
passé comme argument. ~ public E get(int index);
indexOf(Object) ArrayList renvoie l’indice de l’élément passé comme
argument. ~ public int indexOf(Object
elem);
isEmpty() ArrayList teste si l’instance courante ‘ArrayList’
est vide. ~ public boolean isEmpty();
lastIndexOf(Obj) ArrayList renvoie l’indice de la dernière
occurrence de l’élément passé comme argument. ~ public int lastIndexOf(Object elem);
remove(i) ArrayList supprime l’élément désigné par l’indice
‘i’ de l’instance courante en décalant le reste vers la gauche. ~ public E remove(int index);
remove(obj) ArrayList supprime une instance unique de l’élément
désigné par ‘obj’ de la liste courante ; si c’est présent (opération
optionnelle). ~ boolean remove(Object
obj);
removeRange(i,
j) ArrayList supprime, de la liste courante, tous les
éléments du rang i (inclus) à j (exclu). . ~
protected void removeRange(int i, int j);
set(i,
Elt) ArrayList modifie l’élément désigné par l’indice
‘i’ par le nouveau ‘Elt’. ~ public E
set(int index, E element);
size() ArrayList donne la taille (nombre d’éléments) de
l’instance ‘ArrayList’ courante. ~ public int size();
toArray() ArrayList retourne le tableau d’objets (éléments)
correspondants à l’instance courante. ~
public Object[] toArray();
toArray(T[]
a) ArrayList retourne le tableau ‘a’ avec les éléments
de l’instance courante. ~ public
<T> T[] toArray(T[] a);
trimToSize() ArrayList réduit la capacité de l’instance courante
à sa taille réelle. ~ public void trimToSize();
Arrays Nom : public class Arrays extends Object
Arrays() Arrays
constructeur
sans contenu pour interdire toute instanciation dans le
constructeur par défaut.
binarySearch(Tab,
clé) Arrays recherche
itérative et par dichotomie d’une valeur ‘clé’ dans un tableau ‘Tab’ de TypeC.
binarySearch(Tab, clé) Arrays Profil 1 : public static int binarySearch(long [] a, long
key);
binarySearch(Tab, clé) Arrays Profil
2 : public static int binarySearch(int
[] a, int key);
binarySearch(Tab, clé) Arrays Profil
3 : public static int binarySearch(short [] a, short key);
binarySearch(Tab, clé) Arrays Profil
4 : public static int binarySearch(char
[] a, char key);
binarySearch(Tab, clé) Arrays Profil
5 : public static int binarySearch(byte
[] a, byte key);
binarySearch(Tab, clé) Arrays Profil
6 : public static int binarySearch(double[] a, double key);
binarySearch(Tab, clé) Arrays Profil
7 : public static int binarySearch(float [] a, float key);
binarySearch(Tab, clé) Arrays Profil
8 : public static int binarySearch(Object[] a, Object key);
binarySearch(Tab, clé) Arrays Profil
9 : public static <T> int binarySearch( T[] a, T key, Comparator<?
super T> c);
equals(Tab1,
Tab2) Arrays
teste l’égalité entre deux tableaux ‘Tab1’ et ‘Tab2’ de type courant
(TypeC).
equals(Tab1,
Tab2) Arrays Profils 1 à 5 : // A compléter …
equals(Tab1, Tab2) Arrays Profil 6 : public static boolean
equals(boolean[] a, boolean[] a2);
equals(Tab1, Tab2) Arrays Profil 7 : public static boolean
equals(double [] a, double [] a2);
equals(Tab1, Tab2) Arrays Profil 8 : public static boolean
equals(float [] a, float [] a2);
equals(Tab1, Tab2) Arrays Profil 9 : public static boolean
equals(Object [] a, Object [] a2);
deepEquals(a1,
a2) Arrays teste l’égalité entre deux
tableaux ‘a1’ et ‘a2’ dont les éléments sont aussi des tableaux. ~ public
static boolean deepEquals(Object[] a1, Object[] a2);
fill(Tab,
elt) Arrays
remplit tout le tableau ‘Tab’ de
TypeC par la valeur ‘elt’.
fill(Tab, elt) Arrays Profil 1 : public static void
fill(long [] a, long val);
fill(Tab, elt) Arrays Profils 2 à 8 : // A completer …
fill(Tab, elt) Arrays Profil 9 : public static void fill(Object
[] a, object val);
fill(Tab,
d, f, elt) Arrays remplit le tableau ‘Tab’ de l’indice ‘d’
inclus à ‘f’ exclu par la valeur ‘elt’.
fill(Tab, d, f, elt) Arrays Profil 1 : public static void fill(long[]
a, int fromIndex, int toIndex, long val)
fill(Tab,
d, f, elt) Arrays Profils 2 à 9 : // A compléter …
hashCode(Tab)
Arrays retourne le
code de hachage d’un tableau de TypeC (cf. Java 1.5 et plus).
hashCode(Tab)
Arrays Profils 1 à
8 : // A completer …
hashCode(Tab) Arrays Profil 9 : public static int hashCode(Object a[]);
deepHashCode(Tab) Arrays retourne le code de hachage d’un tableau
composé d’autres tableaux. Profil : public static int deepHashCode(Object a[]);
sort(Tab) Arrays trie, par ordre croissant, un tableau
‘Tab’ de TypeC. Les profils 1 à 7 emploient une variante de l’algorithme de tri
rapide (‘QuickSort’) d’après Jon L. Bentley and M. Douglas McIlroy's (cf. "Engineering a Sort Function", Software-Practice
and Experience, Vol. 23(11) P. 1249-1265, November, 1993).
sort(Tab) Arrays Profil 1 : public static void
sort(char []a);
sort(Tab) Arrays Profil 2 : public static void
sort(int []a);
sort(Tab) Arrays Profil 3 : public static void
sort(long []a);
sort(Tab) Arrays Profil 4 : public static void sort(short
[]a);
sort(Tab) Arrays Profil 5 : public static void
sort(byte []a);
sort(Tab) Arrays Profil 6 : public static void
sort(double[]a);
sort(Tab) Arrays Profil 7 : public static void sort(float
[]a);
sort(Tab) Arrays Profil 8 : public static void
sort(Object[] a); l’algorithme utilisé ici est un tri par fusion (‘mergesort’).
Il en est de même pour les profils des méthodes ci-après.
sort(Tab,
comparateur) Arrays Profil
: public static <T> void sort(T[] a, Comparator<? super T> c);
sort(Tab,
d, f, comp) Arrays Profil : public static <T> void
sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c);
l’indice de départ ‘fromIndex’ est inclus alors que l’indice de fin ‘toIndex’
est exclu. Si ces deux indices sont égaux alors la plage à trier est considérée
comme vide.
sort(Tab,
d, f) Arrays
trie, par ordre croissant, un tableau ‘Tab’ de TypeC
d’indice de départ ‘d’ inclus à l’indice de fin ‘f’ exclu.
sort(Tab,
d, f) Arrays
Profil 1 : public static void sort(char []a, int fromIndex, int toIndex);
sort(Tab,
d, f) Arrays
Profils 2 à 7:
// A compléter …
asList(T...
a) Arrays retourne une liste de taille fixe
(‘fixed-size list’) d’après le tableau ‘a’. ~ public static <T>
List<T> asList(T... a); un exemple d’emploi est donné par :
asList(Tab…) Arrays List<String> prenoms =
Arrays.asList("Lison", "Cedric", "Brahim",
"Antoine", "Alexandre");
Calendar() Calendar constructeur par défaut
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.
Collections Nom : public class Collections extends Object
Collections() Collections constructeur sans argument de la classe
concrète ‘Collections’;
sort(list) Collections trie une liste. ~ public static <T extends Comparable<?
super T>> void sort(List<T> list);
sort(list,
comparateur) Collections trie
une liste avec comparateur. ~ public static <T> void
sort(List<T> list, Comparator<? super T> c);
binarySearch(list, key) Collections recherche une clé par dichotomie.
~ public
static <T> int binarySearch( List<? extends Comparable<? super
T>> list, T key)
binarySearch(L,
key, c) Collections
recherche
une clé par dichotomie;
Profil: public static <T>
int binarySearch( List<? extends T> list, T key, Comparator<? super
T> c);
reverse(list) Collections retourne une liste. ~ public
static void reverse( List<?> list );
shuffle(list) Collections permute une liste aléatoirement. ~
public static void shuffle(List<?> list);
shuffle(
list, rnd) Collections permute une liste aléatoirement selon
la source ‘rnd’. ~ public static void shuffle( List<?> list, Random rnd);
swap(lis,
int i, int j) Collections
échange les éléments en position ‘i’ et ‘j’. ~ public
static void swap( List<?> list, int i, int j);
fill(list,
obj) Collections remplit la liste par ‘obj’. ~ public static <T> void fill( List<?
super T> list, T obj);
copy(dest,
src) Collections copie d’une liste ‘src’
vers une liaste ‘dest’. ~ public
static <T> void copy(List<? super T> dest, List<? extends T>
src);
max(coll) Collections retourne le maximum d’une
liste. ~ public static <T
extends Object & Comparable<? super T>> T max(Collection<? extends
T> coll);
max(coll,
comp) Collections retourne le maximum d’une
liste avec comparateur. ~ public static
<T> T max( Collection<? extends T> coll, Comparator<? super
T> comp);
min(coll) Collections retourne le minimum d’une liste.
~ public static <T extends
Object & Comparable<? super T>> T min(Collection<? extends
T> coll);
min(coll,
comp) Collections retourne le minimum d’une
liste avec comparateur. ~ public static
<T> T min( Collection<? extends T> coll, Comparator<? super
T> comp);
rotate(list,
dist) Collections effectue la rotation en
éléments selon la distance spécifiée. Profil[1.4]: public static void rotate(List<?> list,
int distance);
replaceAll(L,
old, new) Collections remplace toutes les occurrences
de valeur ‘old’ par ‘new’. Profil[1.4]:
public static <T> boolean replaceAll(List<T> list, T
oldVal, T newVal);
indexOfSubList(src,
t) Collections Profil[1.4]: public static int
indexOfSubList(List<?> source, List<?> target);
lastIndexOfSubList(s,t) Collections
Profil[1.4]: public static int
lastIndexOfSubList(List<?> source, List<?> target);
.
. . Collections //
A COMPLETER en fonction des besoins …
frequency(Coll,
Obj) Collections renvoie le nombre
d’occurrences de ‘Obj’ dans ‘Coll’. Profil[1.5]: public static int
frequency(Collection<?> c, Object o);
disjoint(Coll1,
Coll2) Collections teste si les deux
collections sont disjointes. Profil(1.5]: public static boolean disjoint(Collection<?> c1,
Collection<?> c2)
addAll(c, T... a) Collections ajoute
tous les éléments spécifiés individuellement (ou non) dans ‘a’ à la collection ‘c’ [<=> c.addAll(Arrays.asList(elements))
]. Profil[1.5]: public static <T> boolean addAll(Collection<?
super T> c, T... a);
Date() Date instancie un objet 'Date' et l'initialise
avec la date et l'heure courante.
Date(long) Date instancie un objet 'Date' et l'initialise
avec le 'long' passé en argument la valeur du 5è argument 'int' comme minute.
after(Date, Date) Date teste si la 1ère date est inférieure à la
seconde.
before(Date,Date) Date teste si la 1ère date est supérieure à la
seconde.
equals(Object) Date teste si deux dates sont égales.
clone() Date renvoie une copie d'un objet 'Date' qui
préfixe l'invocation de la méthode.
getTime() Date renvoie le nombre de milli-sec. depuis le
01.01.1970 à 00:00:00 GMT de l'objet 'Date' qui préfixe l'invocation de la méthode
hashcode() Date renvoie le code de hachage de l'objet
'Date' qui préfixe l'invocation de la méthode
setTime() Date modifie un objet 'Date' qui préfixe
l'invocation de la méthode en lui spécifiant un temps en millisec. après le 1
janvier 1970 à 00:00:00 GMT
toString() Date convertit un objet 'Date' en un 'String'
sous la forme: day month yy
hh:mm:ss zzz yyyy où 'day' est le jour de la semaine (Sun, Mon,
Tue, Wed, Thu, Fri, Sat)
Iterator Nom : 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();
LinkedList Nom : public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, Serializable
LinkedList() LinkedList constructeur par défaut d’une L.C.A.B. (Liste
Chaînée Auto-référencée et Bilatère) vide.
LinkedList(coll) LinkedList constructeur d’une liste à partir d’une
collection. ~ LinkedList(Collection<? extends E> c)
add(o) LinkedList ajoute en queue (~ « Adjq » en
1A) un élément 'o' à la liste courante. ~ public boolean add(E
o)
add(i,
elt) LinkedList ajoute
un élément 'elt' à la liste courante en position ‘i’. ~
public void add(int i, E elt)
addAll(coll) LinkedList ajoute en queue tous les éléments de la
collection 'coll' à la liste courante. ~ public boolean addAll(Collection<? extends E> c)
addAll(i,
coll) LinkedList ajoute en position ‘i’ tous les éléments
de la collection 'coll' à la liste courante. ~ public boolean addAll(int i, Collection<? extends E> c)
addFirst(E o) LinkedList ajoute en tête (~ « Adjt » en 1A) un élément
'o' à la liste courante. ~ public void addFirst(E o).
Exemple
d’emploi :
LinkedList<Integer> listEnt = new
LinkedList<Integer>(); // Java 5
int
unEntier = 2; // par exemple
listEnt.addFirst(
new Integer( unEntier )); // listEnt.addFirst( 2 ); <=> erreur !
addLast(E o) LinkedList ajoute en queue (~ « Adjq » en
1A) un élément 'o' à la liste courante. ~ public void addLast(E o).
clear()) LinkedList enlève tous les éléments de la liste
courante. ~ public void clear(). Exemple d’emploi : listEnt.clear();
clone() LinkedList renvoie une copie superficielle
(«shallow copy») de la liste courante. ~ public Object clone().
contains(Object
o) LinkedList renvoie VRAI si la
liste courante contient l’élément spécifié. ~ public boolean
contains(Object o).
element() LinkedList renvoie la tête
(premier élément) de la liste courante mais ne la détruit pas. ~
public E element().
get(i) LinkedList retourne l’élément en
position ‘i’ de la liste courante (i varie de 0 à size()-1). ~ public E
get(int i)
getFirst() LinkedList renvoie le premier
élément de la liste courante. ~ public E
getFirst().
getLast() LinkedList renvoie le dernier
élément de la liste courante. ~ public E
getLast().
indexOf(Object
o) LinkedList renvoie l’index de
la première occurrence de l’élément spécifié dans la liste
courante, ou -1 si absence. ~ public int indexOf(Object o).
lastIndexOf(o) LinkedList renvoie l’index de
la dernière occurrence de l’élément spécifié dans la liste
courante, ou -1 si absence. ~ public int lastIndexOf(Object o).
listIterator(i) LinkedList retourne un itérateur des éléments de la
liste courante partant de la position ‘i’. ~ ListIterator<E> listIterator(int i).
offer(E
o) LinkedList ajout de l’élément spécifié comme le
(nouveau) dernier élément dans la liste courante. ~ public
boolean offer(E o).
peek() LinkedList renvoie le premier élément de la
liste courante. ~ public E peek().
poll() LinkedList renvoie et efface le
premier élément de la liste courante. ~ public E poll().
remove() LinkedList renvoie et efface le
premier élément de la liste courante. ~ public E remove().
remove(i) LinkedList renvoie et efface l’élément
en position ‘i’ de la liste courante. ~ public E
remove(int i).
remove(obj) LinkedList supprime la première occurrence de
l’élément ‘obj’ de la liste courante. ~ public boolean
remove(Object o).
removeFirst() LinkedList supprime le premier élément (~
« Supt ») de la liste courante et la retourne. ~ public E
removeFirst().
removeLast() LinkedList supprime le dernier élément (~
« Supq ») de la liste courante et la retourne. ~ public E
removeLast().
set(i
, elt) LinkedList remplace l’élément en ‘i’ de la liste
courante par ‘elt’ et retourne l’ancien. ~ public E
set(int i, E elt).
size() LinkedList
donne le nombre total de cellules dans la LCA bilatère courante. ~
public int size(). Emploi: uneListe.size();
toArray() LinkedList renvoie un tableau contenant tous
les éléments de la LCA bilatère courante et dans l’ordre. ~ Object[] toArray().
toArray(T[]
a) LinkedList renvoie un tableau contenant tous
les éléments de la liste courante et dans l’ordre; le type ‘runtime’ du
tableau retourné est celui qui est spécifié. ~
<T> T[] toArray(T[] a).
PriorityQueue() PriorityQueue constructeur sans argument de la classe
« file de priorité » [cf. Java 5.0 et plus].
PriorityQueue(C) PriorityQueue constructeur à un argument, ici ‘C’ désigne
toute référence à une collection Java.
peek() PriorityQueue
accède à la tête de la file de priorité. Emploi: uneFile.peek();
poll() PriorityQueue
extrait la tête de la file de priorité et entasse (‘heapify’) le
reste de la file.
size() PriorityQueue
donne le nombre total d’éléments dans la file de priorité.
Emploi : uneFile.size();
.
. . PriorityQueue . . . // A compléter
nextDouble() Random
. . . // A compléter
nextFloat() Random
. . . // A compléter
nextGaussian() Random
retourne un réel double selon la loi normale centrée et réduite (m=0
et écart-type=1)
nextInt() Random
retourne un entier pseudo-aléa. compris entre Integer.MIN_VALUE et
Integer.MAX_VALUE
nextInt(int n)
Random retourne un
entier pseudo-aléa. compris entre 0 et n (pour version JDK 1.2 ou plus)
nextLong() Random
retourne un entier pseudo-aléatoire compris entre Long.MIN_VALUE
et Long.MAX_VALUE
Stack Nom: public class Stack<E> extends Vector<E>
pop()
Stack dépile
le sommet de la pile courante (i.e. dernier élément de la super-classe
‘Vector’) et le retourne. ~ public synchronized E pop();
push(elt)
Stack empile l’élément
‘elt’ et le retourne aussitôt. ~ public E push(E item);
peek() Stack accède au sommet de la pile mais sans la
dépiler. ~ public synchronized E peek();
empty() Stack retourne ‘true’ si la pile est vide et
‘false’ sinon. ~ public boolean empty();
search(obj) Stack retourne la distance entre ‘obj’ et le
sommet de la pile (= 1 if ‘obj’ == ‘top’). ~ public
synchronized int search(Object o);
Vector Nom : public class Vector<E> extends AbstractList<E> implements List<E>, java.util.RandomAccess, Cloneable, Serializable
Vector() Vector constructeur sans argument de
‘Vector’ (ou Tableau à Grossissement Variable: TGV). Ce
constructeur crée un vecteur vide avec une taille initiale de 10 et un taux
d’accroissement de capacité égal à 0.
Vector(int iCapacity) Vector
constructeur à un argument précisant la capacité initiale ’iCapacity’ et
un taux d’accroissement de capacité égal à 0.
Vector(int iC,int
cI) Vector constructeur
à 2 arguments précisant la capacité
initiale ’iC’ et un taux d’accroissement de capacité égal à ‘cI’.
Vector(Collection
c) Vector constructeur à un argument crée un vecteur contenant
tous les éléments ordonnés (cf. itérateur de ‘c’) de la collection spécifiée.
add(E
o) Vector adjonction en queue de l’instance
courante par l’élément ‘o’. ~
boolean add(E o)
add(int
i, E e) Vector insère un élément ‘e’ au rang ‘i’. ~ void add(int i, E e)
addAll(Collection
c) Vector adjonction en queue de l’instance
courante par tous les éléments de la collection ‘c’. ~ boolean
addAll(Collection<? extends E> c)
addAll(int
i, Col. c) Vector adjonction
en position ‘i’ de l’instance courante par tous les éléments de la
collection ‘c’. ~ boolean addAll(int i, Collection<? extends E>
c)
addElement(E
obj) Vector adjonction en queue « Adjq »
de l’instance ‘Vector’ courante par l’objet ‘obj’. ~ void addElement(E obj)
capacity() Vector renvoie la capacité actuelle de
l’instance courante. ~ int capacity()
clear() Vector enlève tous les éléments de l’instance
courante. ~ void clear()
clone() Vector renvoie une copie (profonde) de
l’instance ‘Vector’ courante. ~ Object clone()
contains(Object
o) Vector teste si l’instance ‘Vector’ courante
contient l’objet ‘o’. ~ boolean
contains(Object o)
containsAll(Coll.
c) Vector teste si l’instance courante contient
tous les éléments de la collection ‘c’. ~
boolean containsAll(Collection<?> c)
copyInto(Object[]
aA) Vector copie
tous les composants de l’instance courante dans le tableau ‘aA’. ~ void copyInto(Object[] anArray)
elementAt(int
i) Vector renvoie le composant en position ‘i’ de
l’instance courante. ~ E
elementAt(int i)
elements() Vector renvoie une énumération des composants
de l’instance courante. ~ Enumeration<E>
elements()
ensureCapacity(minC) Vector
augmente la capacité de l’instance courante à la valaur
‘minC’ afin de couvrir le nombre de composants actuels. ~ void ensureCapacity(int minCapacity)
equals(Object
o) Vector teste si l’instance ‘Vector’ courante
est égale à l’objet ‘o’. ~ boolean equals(Object o)
firstElement() Vector renvoie le premier composant de
l’instance courante (au rang ‘0’). ~ E
firstElement()
get(int
i) Vector renvoie le composant (situé au rang ‘i’)
de l’instance courante. ~ E
get(int index)
hashCode() Vector renvoie la valeur du code de hachage de
l’instance courante. ~ int hashCode()
indexOf(Object
obj) Vector renvoie le rang de la première occurrence
de l’objet ‘o’ en testant l’égalité par ‘equals’. ~ int indexOf(Object o)
indexOf(obj,
int i) Vector renvoie le rang de la première
occurrence (à partir du rang ‘i’) de l’objet ‘o’ dans l’instance courante.
~ int indexOf(Object obj, int i)
insertElementAt(O,
i) Vector insère
l’objet ‘O’ en position ‘i’ de l’instance courante en décalant le reste vers la
droite. ~ void insertElementAt(E
O, int i)
isEmpty() Vector teste si l’objet ‘Vector’ courant
est vide. ~ boolean isEmpty()
lastElement() Vector renvoie le dernier composant de
l’instance courante. ~ E lastElement()
lastIndexOf(Object
o) Vector renvoie le rang de la
dernière occurrence du composant ‘o’ de l’instance courante. ~ int lastIndexOf(Object o)
lastIndexOf(o,
int i) Vector renvoie le rang de
la dernière occurrence du composant ‘o’ de l’instance courante, partant du rang
‘i’ et vers le début. ~ int
lastIndexOf(Object o, int i)
remove(int
i) Vector enlève et renvoie le composant
(au rang ‘i’) de l’instance courante. ~
E remove(int i)
remove(Object
o) Vector enlève le composant ‘o’ de l’instance
courante s’il existe. ~ boolean remove(Object o)
removeAll(c)
Vector enlève tous les éléments de la
collection ‘c’ de l’instance courante. ~
boolean
removeAll(Collection<?> c)
removeAllElements() Vector
détruit tous les éléments de l’instance courante ( <=> clear()
). ~ void removeAllElements() //
==> size() = 0.
removeElement(obj) Vector
enlève la première occurrence de l’élément ‘obj’ de l’instance
courante. ~ boolean
removeElement(Object obj)
removeElementAt(i) Vector
enlève l’élément en position ‘i’ de l’instance courante. ~ void removeElementAt(int i)
removeRange(deb,
fin) Vector enlève tous les
éléments entre l’index du début ‘deb’ inclus à l’index ‘fin’ exclus de
l’instance courante. ~ protected void removeRange(int deb, int fin)
retainAll(coll) Vector ne garde que les éléments qui sont
contenus dans la collection spécifiée ‘coll’ pour l’instance courante. ~ boolean retainAll(Collection<?> coll)
set(int
i, E elt) Vector remplace l’élément en position
‘i’ par ‘elt’ dans l’instance courante et renvoie l’ancien composant. ~ E set(int i, E elt)
setElementAt(E
O, i) Vector remplace l’élément en position
désignée par l’entier ‘i’ par l’objet ‘O’. ~
void setElementAt(E O, int i)
setSize(int
nouv_t) Vector modifie la taille de l’instance
courante. Si nouv_t < anc_t, les
derniers éléments sont perdus; dans le cas contraire, des éléments ‘null’
seront ajoutés pour atteindre la nouvelle taille ‘nouv_t’. ~ void setSize(int newSize) // <=> nouvelle taille ‘nouv_t’
size() Vector donne la taille de l’instance ‘Vector’
courante. ~ int size() - Ex. : int anc_t = this.size();
subList(deb,
fin) Vector renvoie une partie des éléments du rang
‘deb’ inclus au rang ‘fin’ exclus de l’instance courante. ~ List<E> subList(int deb, int
fin)
toArray()
Vector renvoie un tableau contenant tous les
composants de l’instance courante. ~ Object[]
toArray()
toArray(T[]
a) Vector renvoie un tableau contenant tous les
composants de l’instance courante; le type du tableau retourné est spécifié par
celui de l’argument lors de l’exécution. ~
<T> T[] toArray(T[] a)
toString() Vector renvoie une chaîne de caractères
décrivant le contenu de l’instance courante. ~
String toString()
trimToSize()
Vector réduit la capacité de l’instance
courante à sa taille réelle actuelle. ~ void trimToSize()