COLLECTIONS JAVA

Master STRI20, H. Mouncif, @ 1

 Stocke des elements generiques
sous formes de cle-valeur

Master STRI20, H. Mouncif, @ 2

Parcourir une collection
Comme vous le savez déjà, il y a deux façons de parcourir une collection, en fonction de son type :

soit avec un itérateur ou un simple boucle pour les collections de type Collection ;

soit avec une Collection pour les collections de type Map.

Je vous propose de refaire un point rapide sur la façon de procéder. Promis, ça ne sera pas long
et ça vous sera bien utile pour la suite. :)

Parcourir une implémentation de type Collection

Ce type d'interface comporte un objet bien pratique : un Iterator. Voici les méthodes présentes
dans cette interface :

public interface Iterator<E> { E --> designe les objets stockes

boolean hasNext(); hasNext() (boucle while):verifie est-ce qu'il y a unn objet qu'on n'a pas encore parcourue
E next(); next() : passe la reference de l'objet suivant
void remove();
}

Master STRI20, H. Mouncif, @ 3

Cet objet vous permet donc de :

parcourir une collection, via la méthode hasNext(). Cette méthode retourne true s'il reste des éléments à
parcourir ;

récupérer un élément, grâce à la méthode next(). Celle-ci retourne l'élément courant dans l'itérateur. Si vous
invoquez cette méthode plusieurs fois dans une boucle de parcours, cela vous fait avancer dans la lecture de la
collection, un peu comme si vous incrémentiez plusieurs fois le compteur d'une boucle for ;

supprimer un élément, en utilisant la méthode remove(). Cette méthode n'est utilisable qu'après avoir utilisé la
méthode next() et n'est utilisable qu'une seule fois par appel à la méthode next().

Master STRI20, H. Mouncif, @ 4

import java.util.ArrayList;
import java.util.Iterator; //tant qu'il y a des éléments à parcourir
while(it.hasNext()){ hasNext()---> tjrs comme condition
Next()----> a l'interieur
public class Main { nbTourDeBoucle++;
//nous récupérons l’élément courant
public static void main(String[] args) { String str = (String)it.next();
//nous créons une collection basique //si nous sommes sur l'élément 4, nous le retirons de la collection
ArrayList<String> list = new ArrayList<String>(); if(str.equals("4"))
list.add("1"); it.remove();
list.add("2"); }
list.add("3");
list.add("4"); //nous reparcourons un nouvel itérateur
list.add("5"); //pour nous assurer que tout a fonctionné
list.add("6"); it = list.iterator();
list.add("7");
while(it.hasNext()){
//Un petit compteur pour récupérer les tours de boucle
int nbTourDeBoucle = 0; nbTourDeBoucle2++;
int nbTourDeBoucle2 = 0; System.out.println(it.next());
System.out.println(it.next());
//Nous récupérons notre itérateur System.out.println(it.next());
Iterator it = list.iterator(); //iterator deja predefinis }

System.out.println("Nombre de tours de boucle N°1 : " + nbTourDeBoucle);

System.out.println("Nombre de tours de boucle N°2 : " + nbTourDeBoucle2);

}
}
Master STRI20, H. Mouncif, @ 5
Parcourir une collection de type Map
En fait, les objets implémentant cette interface sont un peu particuliers de par leur nature à gérer des couples d’éléments. Du coup, les concepteurs
du langage vous proposent trois façons de parcourir une telle collection, en implémentant des méthodes de l’interface Collection :

la méthode keySet() qui retourne une collection de type Set<K> lorsque "K" est le type de la clé de notre Map<K, V>.

la méthode entrySet() qui retourne elle aussi une implémentation de l'interface Set, mais de type différent. La collection retournée sera définie ainsi
Set<Entry<K, V>>. Ce sera donc une collection d'objets qui contiendra tous les couples clé - valeur de notre Map. Cet objet est en fait une classe
interne à l'interface Map et contient quelques méthode utiles pour récupérer des informations.

et enfin la méthode values() qui retourne ce type d'objet Collection<String>, c'est-à-dire la liste de nos valeurs.

Voici un code d'exemple afin de vous familiariser avec ces trois façons de faire :

Master STRI20, H. Mouncif, @ 6

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set; Set<Entry<Integer, String>> setEntry = map.entrySet();
//Utilisation d'un iterateur générique
Iterator<Map.Entry<Integer, String>> itEntry = setEntry.iterator();
public class Main2 { System.out.println("Parcours d'une Map avec setEntry : ");
//ensuite vous savez faire
/** while(itEntry.hasNext()){
* @param args Map.Entry<Integer, String> entry = itEntry.next();
*/ System.out.println("Valeur pour la clé " + entry.getKey() + " = " +
public static void main(String[] args) { entry.getValue());
Map<Integer, String> map = new HashMap<Integer, String>(); }
map.put(1, "toto"); System.out.println("-----------------------------------");
map.put(2, "titi");
map.put(3, "tutu");
map.put(4, "tete"); Collection<String> col = map.values();
map.put(5, "tata"); Iterator<String> itString = col.iterator();
System.out.println("Parcours de la liste des valeurs d'une Map avec values : ");
//Nous récupérons un Set contenant des entiers //ensuite vous savez faire
Set<Integer> setInt = map.keySet(); while(itString.hasNext()){
//Utilisation d'un itérateur générique String value = itString.next();
Iterator<Integer> it = setInt.iterator(); System.out.println("Valeur : " + value);
System.out.println("Parcours d'une Map avec keySet : "); }
//ensuite vous savez faire System.out.println("-----------------------------------");
while(it.hasNext()){
int key = it.next(); }
System.out.println("Valeur pour la clé " + key + " = " + map.get(key)); }
}
System.out.println("-----------------------------------");

Master STRI20, H. Mouncif, @ 7