!     The following file gives the list of some Java methods and
!!    their corresponding classes in the package java.util.
!!!   For more details, please read the API documentation (JDK 1.6).
!!!!  (c) ~/2a env. ~ Permanent update: 01.02.2011 09h29 / H. Nguyen-Phu
!!!!! ArrayDeque; ArrayList; Arrays; Collections; LinkedList;

!!!!! PriorityQueue; Random; Stack; Vector

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

Signatures Classes [Remarques.] & Profil;

ArrayDeque<E> : public class ArrayDeque<E> extends AbstractCollection<E> implements Deque<E>, Cloneable, Serializable
 

ArrayDeque() ArrayDeque constructeur sans arguments pour contenir 16 éléments. + ArrayDeque();

ArrayDeque(i_Capa) ArrayDeque constructeur avec capacité initiale de stockage. + ArrayDeque(int i_capa);

ArrayDeque(coll) ArrayDeque constructeur avec capacité initiale égale à la taille de la collection ‘coll’. + ArrayDeque(Collection<? extends E> c);

add(O) ArrayDeque + boolean add(E o);

addFirst(O) ArrayDeque + void addFirst(E o);

addLast(O) ArrayDeque + void addLast(E o);

clear() ArrayDeque efface tous les éléments de l’instance courante. + void clear();

clone() ArrayDeque renvoie un clone de cette dèque. + ArrayDeque<E> clone();

contains(O) ArrayDeque + boolean contains( Object O);

descendingIterator() ArrayDeque + Iterator<E> descendingIterator();

element() ArrayDeque + E element();

getFirst() ArrayDeque + E getFirst();

getLast() ArrayDeque + E getLast();

isEmpty() ArrayDeque teste si cette dèque est vide. + boolean isEmpty();

iterator() ArrayDeque + Iterator<E> iterator();

offer(e) ArrayDeque + boolean offer(E e) { return offerLast(e); }

offerFirst(E e) ArrayDeque + boolean offerFirst(E e) { addFirst(e); return true; }

offerLast(E e) ArrayDeque + boolean offerLast(E e) { addLast(e); return true; }

peek() ArrayDeque + E peek() { return peekFirst(); }

peekFirst() ArrayDeque + E peekFirst() { return elements[head]; }

peekLast() ArrayDeque + E peekLast();

poll() ArrayDeque + E poll() { return pollFirst(); }

pollFirst() ArrayDeque + E pollFirst();

pollLast() ArrayDeque + E pollLast();

pop() ArrayDeque + E pop() { return removeFirst(); }

push(e) ArrayDeque + void push(E e) { return addFirst(e); }

remove() ArrayDeque + void remove(); // proc. de suppression du dernier élément ?!

remove() ArrayDeque + E remove() { return removeFirst(); }

remove(obj) ArrayDeque + boolean remove(Object obj) { return removeFirstOccurrence(o); }

removeFirst() ArrayDeque Elle est équivalente à ‘pollFirst()’ mais relaie l’exception ‘NoSuchElementException’ si la dèque est vide. + E removeFirst();

removeFirstOccurrence(O) ArrayDeque + boolean removeFirstOccurrence(Object O);

removeLast() ArrayDeque Elle est équivalente à ‘pollLast()’ mais relaie l’exception ‘NoSuchElementException’ si la dèque est vide. + E removeLast();

removeLastOccurrence(O) ArrayDeque + boolean removeLastOccurrence(Object O);

size() ArrayDeque + int size();

toArray() ArrayDeque retourne le tableau d’objets (éléments) correspondants à la dèque courante. + Object[] toArray();

toArray(T[] a) ArrayDeque retourne le tableau ‘a’ avec les éléments de la dèque courante. + <T> T[] toArray(T[] a);

ArrayList<E> : public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable

ArrayList() ArrayList constructeur sans arguments avec capacité initiale de 10. + ArrayList() { this(10); }

ArrayList(i_Capa) ArrayList constructeur avec capacité initiale de stockage. + ArrayList(int initialCapacity);

ArrayList(coll) ArrayList constructeur muni d’une taille (‘size’) égale à celle de la collection ‘coll’. + ArrayList(Collection<? extends E> c);

add(O) ArrayList + boolean add(E o);

add(i, O) ArrayList + void add(int index, E element);

addAll(Coll) ArrayList + boolean addAll(Collection<? extends E> c);

addAll(i, Coll) ArrayList + boolean addAll(int index, Collection<? extends E> c);

clear() ArrayList + void clear();

clone() ArrayList renvoie un clone de cette liste. + Object clone();

contains(O) ArrayList + boolean contains(Object O);

ensureCapacity(min) ArrayList assure la capacité minimale spécifiée par ‘min’ de l’objet courant. + void ensureCapacity(int minCapacity);

get(indice) ArrayList + E get(int index);

indexOf(O) ArrayList + int indexOf(Object O);

isEmpty() ArrayList + boolean isEmpty() { return size == 0 ; }

lastIndexOf(O) ArrayList + int lastIndexOf(Object O);

remove(i) ArrayList + E remove(int index);

remove(o) ArrayList + boolean remove(Object obj);

removeRange(i, j) ArrayList supprime, de cette liste, tous les éléments du rang i (inclus) à j (exclu). # void removeRange(int i, int j);

set(i, Elt) ArrayList + E set(int index, E element);

size() ArrayList + int size() { return size; }

toArray() ArrayList + Object[] toArray();

toArray(T[] a) ArrayList + <T> T[] toArray(T[] a);

trimToSize() ArrayList réduit la capacité de cette liste courante à sa taille réelle. + void trimToSize();

Arrays : 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 : + static int binarySearch(long [] a, long key);

binarySearch(Tab, clé) Arrays Profil 2 : + static int binarySearch(int [] a, int key);

binarySearch(Tab, clé) Arrays Profil 3 : + static int binarySearch(short [] a, short key);

binarySearch(Tab, clé) Arrays Profil 4 : + static int binarySearch(char [] a, char key);

binarySearch(Tab, clé) Arrays Profil 5 : + static int binarySearch(byte [] a, byte key);

binarySearch(Tab, clé) Arrays Profil 6 : + static int binarySearch(double[] a, double key);

binarySearch(Tab, clé) Arrays Profil 7 : + static int binarySearch(float [] a, float key);

binarySearch(Tab, clé) Arrays Profil 8 : + static int binarySearch(Object[] a, Object key);

binarySearch(Tab, clé) Arrays Profil 9 : + 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 : + static boolean equals(boolean[] a, boolean[] a2);

equals(Tab1, Tab2) Arrays Profil 7 : + static boolean equals(double [] a, double [] a2);

equals(Tab1, Tab2) Arrays Profil 8 : + static boolean equals(float [] a, float [] a2);

equals(Tab1, Tab2) Arrays Profil 9 : + 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. + 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 : + static void fill(long [] a, long val);

fill(Tab, elt) Arrays Profils 2 à 8 : // A completer …

fill(Tab, elt) Arrays Profil 9 : + 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 : + 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 : + static int hashCode(Object a[]);

deepHashCode(Tab) Arrays retourne le code de hachage d’un tableau composé d’autres tableaux. Profil : + 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 : + static void sort(char []a);

sort(Tab) Arrays Profil 2 : + static void sort(int []a);

sort(Tab) Arrays Profil 3 : + static void sort(long []a);

sort(Tab) Arrays Profil 4 : + static void sort(short []a);

sort(Tab) Arrays Profil 5 : + static void sort(byte []a);

sort(Tab) Arrays Profil 6 : + static void sort(double[]a);

sort(Tab) Arrays Profil 7 : + static void sort(float []a);

sort(Tab) Arrays Profil 8 : + 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 : + static <T> void sort(T[] a, Comparator<? super T> c);

sort(Tab, d, f, comp) Arrays Profil : + 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 : + 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’. + 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");

Collections : public class Collections extends Object

Collections() Collections constructeur sans arguments

sort(list) Collections trie une liste. + static <T extends Comparable<? super T>> void sort(List<T> list);

sort(list, comparateur) Collections trie une liste avec comparateur. + static <T> void sort(List<T> list, Comparator<? super T> c);

binarySearch(list, key) Collections recherche une clé par dichotomie. + static <T> int binarySearch( List<? extends Comparable<? super T>> list, T key)

binarySearch(L, key, c) Collections recherche une clé par dichotomie; Profil: + static <T> int binarySearch( List<? extends T> list, T key, Comparator<? super T> c);

reverse(list) Collections retourne une liste. + static void reverse( List<?> list );

shuffle(list) Collections permute une liste aléatoirement. + static void shuffle(List<?> list);

shuffle( list, rnd) Collections permute une liste aléatoirement selon la source ‘rnd’. + static void shuffle( List<?> list, Random rnd);

swap(lis, int i, int j) Collections échange les éléments en position ‘i’ et ‘j’. + static void swap( List<?> list, int i, int j);

fill(list, obj) Collections remplit la liste par ‘obj’. + static <T> void fill( List<? super T> list, T obj);

copy(dest, src) Collections copie d’une liste ‘src’ vers une liste ‘dest’. + static <T> void copy(List<? super T> dest, List<? extends T> src);

max(coll) Collections retourne le maximum d’une liste. + 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. + static <T> T max( Collection<? extends T> coll, Comparator<? super T> comp);

min(coll) Collections retourne le minimum d’une liste. + 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. + 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]: + static void rotate(List<?> list, int distance);

replaceAll(L, old, new) Collections remplace toutes les occurrences de valeur ‘old’ par ‘new’. Profil[1.4]: + static <T> boolean replaceAll(List<T> list, T oldVal, T newVal);

indexOfSubList(src, t) Collections Profil[1.4]: + static int indexOfSubList(List<?> source, List<?> target);

lastIndexOfSubList(s,t) Collections Profil[1.4]: + 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]: + static int frequency(Collection<?> c, Object o);

disjoint(Coll1, Coll2) Collections teste si les deux collections sont disjointes. Profil(1.5]: + 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]: + static <T> boolean addAll(Collection<? super T> c, T... a);

Date : public class Date implements java.io.Serializable, Cloneable, Comparable<Date>

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)

LinkedList<E> : public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, Serializable

LinkedList() LinkedList constructeur sans arguments d’une L.C.A.B. (Liste Chaînée Auto-référencée et Bilatère) vide. + LinkedList();

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' à cette liste. + boolean add(E o);

add(i, elt) LinkedList ajoute un élément 'elt' à la liste courante en position ‘i’. + void add(int i, E elt);

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

addAll(i, coll) LinkedList ajoute en position ‘i’ tous les éléments de la collection 'coll' à cette liste. + 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. + void addFirst(E o);

Un 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. + void addLast(E o);

clear() LinkedList enlève tous les éléments de la liste courante. + void clear(). Exemple d’emploi : listEnt.clear();

clone() LinkedList renvoie une copie superficielle («shallow copy» i.e. les éléments eux mêmes ne sont pas clonés) de la liste courante. + Object clone();

contains(Object o) LinkedList renvoie VRAI si la liste courante contient l’élément spécifié. + boolean contains(Object o);

element() LinkedList renvoie la tête (premier élément) de la liste courante mais ne la détruit pas. + E element();

get(i) LinkedList retourne l’élément en position ‘i’ de la liste courante (i varie de 0 à size()-1). + E get(int i);

getFirst() LinkedList + E getFirst();

getLast() LinkedList + E getLast();

indexOf(o) LinkedList renvoie l’index de la première occurrence de l’élément spécifié dans la liste courante, ou -1 si absence. + 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. + 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 cette liste. + boolean offer(E o);

peek() LinkedList + E peek(); // <=> ‘getFirst()’ si la tête existe

poll() LinkedList renvoie et efface le premier élément de la liste courante. + E poll(); // <=> ‘removeFirst()’ si la tête existe

remove() LinkedList renvoie et efface le premier élément de cette liste. + E remove();

remove(i) LinkedList renvoie et efface l’élément en position ‘i’ de cette liste. + E remove(int i);

remove(o) LinkedList supprime la première occurrence de l’élément ‘o’ de cette liste. + boolean remove(Object o);

removeFirst() LinkedList supprime le premier élément (~ « Supt » en 1A) de cette liste et la retourne. + E removeFirst();

removeLast() LinkedList supprime le dernier élément (~ « Supq » en 1A) de cette liste et la retourne. + E removeLast();

set(i , elt) LinkedList remplace l’élément en ‘i’ de cette liste par ‘elt’ et retourne l’ancien. + E set(int i, E elt);

size() LinkedList donne le nombre total de cellules dans la LCAB courante. + int size(). Ex. d’emploi: uneListe.size();

toArray() LinkedList renvoie un tableau contenant tous les éléments de la LCAB courante et dans l’ordre. + Object[] toArray();

toArray(T[] a) LinkedList renvoie un tableau contenant tous les éléments de cette liste et dans l’ordre; le type ‘runtime’ du tableau retourné est celui qui est spécifié. + <T> T[] toArray(T[] a);

PriorityQueue<E> : public class PriorityQueue<E> extends AbstractQueue<E> implements java.io.Serializable (cf. JDK 1.5)

PriorityQueue() PriorityQueue constructeur sans argument de la classe « file de priorité ».

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

Random : public class Random implements java.io.Serializable

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<E> : 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. + synchronized E pop();

push(elt) Stack empile l’élément ‘elt’ et le retourne aussitôt. + E push(E item);

peek() Stack accède au sommet de la pile mais sans la dépiler. + synchronized E peek();
empty() Stack retourne ‘true’ si la pile est vide et ‘false’ sinon. + boolean empty();
search(obj) Stack retourne la distance entre ‘obj’ et le sommet de la pile (= 1 if ‘obj’ == ‘top’). + synchronized int search(Object o);

Vector<E> : public class Vector<E> extends AbstractList<E> implements List<E>, RandomAccess, cloneable, java.io.Serializable

Vector() Vector constructeur sans arguments 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();

Vector(iCapacity) Vector constructeur à un argument précisant la capacité initiale ’iCapacity’ et un taux d’accroissement de capacité égal à 0. + Vector(int iCapacity);

Vector(iC, cI) Vector constructeur à 2 arguments précisant la capacité initiale ’iC’ et un taux d’accroissement de capacité égal à ‘cI’. + Vector(int iC,int cI);

Vector(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. + Vector(Collection<? extends E> c);

add(o) Vector + boolean add(E o);

add(i, elt) Vector + void add(int i, E e);

addAll(coll) Vector + boolean addAll(Collection<? extends E> c);

addAll(i, coll) Vector + boolean addAll(int i, Collection<? extends E> c);

addElement(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 + void clear();

clone() Vector renvoie une copie (profonde) de l’instance ‘Vector’ courante. + synchronized Object clone();

contains(o) Vector + boolean contains(Object o);

containsAll(coll) Vector + synchronized boolean containsAll(Collection<?> c);

copyInto(Object[] aA) Vector copie tous les composants de ce vecteur dans le tableau ‘aA’. + synchronized void copyInto(Object[] anArray);

elementAt(i) Vector renvoie le composant en position ‘i’ de ce vecteur. + synchronized E elementAt(int i);

elements() Vector renvoie une énumération des composants de ce vecteur. + Enumeration<E> elements();

ensureCapacity(minC) Vector augmente la capacité de ce vecteur à la valeur ‘minC’ afin de couvrir le nombre de composants actuels. + synchronized void ensureCapacity(int minCapacity);

equals(o) Vector + synchronized boolean equals(Object o);

firstElement() Vector renvoie le premier composant de ce vecteur (au rang ‘0’). + synchronized E firstElement();

get(i) Vector + synchronized E get(int index);

hashCode() Vector + synchronized int hashCode();

indexOf(o) Vector + int indexOf(Object o);

indexOf(obj, i) Vector renvoie le rang de la première occurrence (à partir du rang ‘i’) de l’objet ‘o’ dans ce vecteur. ~ 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 + synchronized boolean isEmpty();

lastElement() Vector renvoie le dernier élément de ce vecteur. + synchronized E lastElement();

lastIndexOf(o) Vector + synchronized int lastIndexOf(Object o);

lastIndexOf(o, i) Vector renvoie le rang de la dernière occurrence de l’élément ‘o’ de ce vecteur, en partant du rang ‘i’ et vers le début. + synchronized int lastIndexOf(Object o, int i);

remove(i) Vector + synchronized E remove(int i);

remove(o) Vector + boolean remove(Object o);

removeAll(c) Vector + synchronized boolean removeAll(Collection<?> c);

removeAllElements() Vector détruit tous les éléments de ce vecteur. + synchronized void removeAllElements(); // => this.size() = 0;

removeElement(o) Vector enlève la première occurrence de l’élément ‘o’ de ce vecteur. + synchronized boolean removeElement(Object o);

removeElementAt(i) Vector enlève l’élément en position ‘i’ de l’instance courante. + synchronized  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 ce vecteur. # synchronized void removeRange(int deb, int fin);

retainAll(coll) Vector + synchronized boolean retainAll(Collection<?> coll);

set(i, elt) Vector + synchronized E set(int i, E elt);

setElementAt(O, i) Vector remplace l’élément en position désignée par l’entier ‘i’ par l’objet ‘O’. + synchronized void setElementAt(E O, int i);

setSize(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’. + synchronized void setSize(int nouv_t);

size() Vector + synchronized int size();

subList(deb, fin) Vector + synchronized List<E> subList(int deb, int fin);

toArray() Vector + synchronized Object[] toArray();

toArray(T[] a) Vector + synchronized <T> T[] toArray(T[] a);

toString() Vector renvoie une chaîne de caractères décrivant le contenu de ce vecteur. + synchronized String toString();

trimToSize() Vector réduit la capacité de ce vecteur à sa taille réelle. + synchronized void trimToSize();