précédent | suivant | table des matières s'évaluer

Collections

Cette classe contient des méthodes statiques permettant de manipuler des collections :

Ces méthodes lèvent toutes une NullPointerException, si la ou les collections en paramètre ont valeur null.

1Recherche et tris :

int binarySearch(List<? extends Comparable<? super T>> liste, T cle) 
int binarySearch(List<? extends T> liste, T cle, Comparator<? super T> c)
 Recherche dichotomique de cle dans une liste, en utilisant compareTo, ou un Comparator. 
T max(Collection<? extends T> coll)
T max(Collection <? extends T> coll, Comparator<? super T> comp)  
 Maximum des objets d'une collection, en utilisant le compareTo des objets ou le Comparator. 
T min(Collection <? extends T> coll)
T min(Collection <? extends T> coll, Comparator<? superT> comp) 
 Minimum des objets d'une collection, en utilisant le compareTo des objets ou le Comparator. 
void sort (List<T> liste)
void sort (List<T> liste, Comparator<? super T>)
 Tri des éléments de la liste en utilisant la méthode compareTo des éléments. Ce tri est stable. La méthodes crée un tableau des éléments de la liste et trie ce tableau. 
int indexOfSubList(List source, List target) 
int lastIndexOfSubList(List source, List target)
 Retourne l’indice de la première occurrence  de source dans target ( -1 si pas trouvé)

Changer l'ordre des éléments :

void reverse(List<?> l)
 Inverse l'ordre des éléments de la liste l. 
void rotate( List<?> l, int distance)
 Effectue une rotation sur les éléments de la liste l. l'élément d'indice i devient l'élément d'indice (i+distance) % l.size(). 
void shuffle (List <?> l)
 Permute de façon aléatoire les éléments de la liste. Le germe de la suite aléatoire est le germe par défaut.. 
void shuffle (List <?> l, Random r)
 Permute de façon aléatoire les éléments de la liste. Le  germe de la suite aléatoire R. 
void swap(List<?> l, inti, int j)
 Echange les éléments de la liste l d'indices i et j.

3 Divers :

Comparator<T> reverseOrder()
Comparator<T> reverseOrder(Comparator<T> comp)
 Retourne un Comparator qui imposerait l'ordre inverse du compareTo, ou de comp. 
void copy (List<? super T> dest, List<? extends T> source)
 Copie tous les éléments de la liste source, vers la liste dest. La liste dest doit être au moins aussi longue que source. Si dest est plus long que source, les éléments supplémentaires sont inchangés. 
void fill(List<? super T>l, T o)
 Remplace tous les éléments de lal iste l par o. 
boolean replaceAll(List<T> l, T aV, T nV)
 Remplace, dans la liste l, toutes les occurrences de aV, par nV. Retourne true s'il y a eut au moins un remplacement, et false sinon. 
int frequency(Collection<? >c, Object o)
 Retourne le nombre d'occurrences de l'objet o dans la collection c. 
List<T> nCopies(int n, T o)
 Retourne une liste constituée de n fois l'objet o. La liste retournée est immuable,  et ne contient que des références au même objet o.

4Collections synchronisées :

Les  différentes méthodes des classes collection ne sont pas synchronisées,  la classe Collections offre des méthodes permettant d'obtenir pour chaque classe une enveloppe synchronisée de la classe.

Collection<T> synchronizedCollection(Collection<T> c)
 Retourne une vue synchronisée de la collection c. Toutes les méthodes de la collection c sont synchronisées.
Les classes synchronisées sont construites sur le schéma suivant :
SynchronizedX<E> implements X<E>, Serializable {
   X<E> c;        // le X sous jacent
   Object mutex;  // l'objet sur lequel synchroniser
   SynchronizedX(X<E> c) {<
      if (c==null)  throw new NullPointerException();
      this.c = c;
      mutex = this;
   }
   public Type f() {
      synchronized(mutex) {  return c.f();  }
   }
   . . . 
}
 
List<T> synchronizedList(List<T> l)
 
Map<T> synchronizedMap(Map<T> m)
 
Set<T> synchronizedSet(Set<T> s)
 
SortedMap<T> synchronizedSortedMap(SortedMap<T> s)
 
SortedSet<T> synchronizedSortedSet(SortedSet<T> s)

5unmodifiable :

Les méthodes suivantes retourne une collection qui est non modifiable : c'est à dire que les opérations d'ajout et de suppression sont devenues interdites ; elles lèvent l'exception UnsupportedOperationException. 

unmodifiableCollection(Collection<? extends T>)
 Retourne une vue non modifiable de la collection. 
unmodifiableList(List<? extends T>)
 Retourne une vue non modifiable de la liste. 
unmodifiableMap(Map<? extends K, ? extends V>)
 Retourne une vue non modifiable de la mapppe. 
undunmodifiableSet(Set<? extends T>)
 Retourne une vue non modifiable du set. 
unmodifiableSortedMap(SortedMap<K, ? extends V>)
 Retourne une vue non modifiable du sortedMap. 
unmodifiableSortedSet(SortedSet<T>)
 Retourne une vue non modifiable du sortedSet.

La collection non modifiable et la collection d'origine, partagent la même représentation des données. Celà entraine que si on modifie ( ajout ou suppression) la collection d'origine, la collection non modifiable est modifiée !

   List<String> lOrigine = new ArrayList<String>();
   list.add("un");
   Collection<String> nonModifiable = Collections.unmodifiableCollection(lOrigine);
   lOrigine.add("deux");
   System.out.print(nonModifiable);

Affiche [un, deux] à la console.


haut de la page