Java.util - Pierre Rainero

Programmation orienté objet :
Package java.util :
Le package java.util apporte de nombreux éléments qui nécessitent des importations
explicites obligatoire :
- Manipulation des dates (Classe Calendar) → Permet d’obtenir le point courant dans le temps
- Collections de données (listes, dictionnaires, …)
- Internationalisation (Classe Locale)
- Sous package concurrent
- Sous package regex
- Sous package prefs
- etc…
L’importation se fait à l’aide la commande suivante (au début) : « import java.util.*; »
Notion de package :
Un package est un regroupement fonctionnel cohérent de :
- Classes Java (fichiers .class)
- Interfaces Java (fichiers .class)
- Sous packages
Un fichier src.jar est installé par défaut, avec désignation dans la variable d’environnement
CLASSPATH.
Les collections :
Forme d’agrégat dans lequel tous les composants sont de même type (ensemble homogène) :
- Nombre variable d’éléments
- Définition d’une relation d’appartenance
- Contrôle de validité et d’appartenance
- Construction récurrente possible et simple
- Gestion intégrée de la persistance
- Généricité vis-à-vis du type des éléments stockés
Cahier des charges d’une collection :
- Spécifications des contraintes de rangement
- Spécifications des modes de désignation
- Spécifications des contrôles en ligne
- Contraintes de performances
- Contraintes d’interface
- Contraintes opérationnelles
Désignation simple ou multiple :
- Désignation par la position absolue
- Désignation par la position relative
- Désignation par une clé d’identification
- Désignation par le contenu
- Composition de désignations
- Désignation de sous-ensembles
Java collections framework :
- Les interfaces Collection, List, Setet Map
- Listes (ArrayList, LinkedList, …)
- Dictionnaires (HahMap, LinkedHashMap, …)
- Ensembles (HashSet, TreeSet, …)
- etc…

 Chaque élément est une référence (sur objet)
- Tous les objets cibles sont de même type
- Transtypage dynamique implicite ascendant (Object)
- Problème des vues multiples éventuelles (Clonage recommandé)
Les listes sont des agrégats ordonnés d’objets contrairement aux dictionnaires qui sont des
agrégats non ordonné d’associations. Une association est un couple objet/objet :
Deux éléments
Clef primaire Associé
L’agrégat est non ordonné mais le type des clefs doit avoir une relation d’ordre :
Si la clef est un entier → ordre croissant
Si la clef est un string → ordre alphabétique
Si la clef est une instance créée par le programmeur (exemple navire) → Ne fonctionne pas
Principales méthodes :
 Liste :
- Taille courante d'une liste (size)
- Accesseurs de consultation (get, getFirst, …)
- Accesseurs de modification (set)
- Accesseurs de position (indexOf)
- Ajouter un nouvel élément (add)
- Retirer un élément (remove)
- Vider une liste (clear)
- Contrôle d'appartenance (contains)
- Transférer dans un tableau (toArray)
1. Créer et initialiser une liste :
import java.util.*;
public class Exemple_2_1 {
public void main(String[] args) {
LinkedList notes= new LinkedList();
notes.add(new Integer(17)) ;
notes.add(new Integer(11)) ;
notes.add(new Integer(6)) ;
System.out.println ("Notes= " + notes);
}
}
2. Parcourir une liste :
…
public static float moyenne(final LinkedList notes) {
float somme=0.0f;
Iterator i= notes.iterator();
while (i.hasNext())
somme += ((Float)i.next()).floatValue();
return somme/notes.size();
}
Élément
à gauche
Élément
à droite
Dans une liste on doit utiliser un itérateur car on ne sait pas comment est faite la liste.
Toutes les collections ordonnées possède une méthode « iterator() ».

Explications :
La méthode hasNext retourne un booléen (vrai dans le cas où il y a un élément suivant)
La méthode next retourne l’objet correspondant au rang de l’itérateur puis incrémente
celui-ci de 1.
3. Dupliquer une liste :
LinkedList source= new LinkedList();
LinkedList copie;
copie= (LinkedList)source.clone();
Cela crée des doubles vues, on ne duplique pas les éléments de la liste « source » on duplique
uniquement la liste (si on modifie un élément de la liste « source », l’élément sera donc aussi
modifié dans la liste « copie »).
 Dictionnaire :
- Taille courante d'un dictionnaire (size)
- Accesseurs de consultation (get, keySet, entrySet, …)
- Accesseurs de modification (put)
- Ajouter un nouvel élément (put) – put modifie l’élément s’il existe
- Retirer un élément (remove)
- Vider un dictionnaire (clear)
- Contrôles d'appartenance (containsKey, containsValue)
1. Créer et initialiser un dictionnaire :
public class Exemple_5 {
public static void main (String[] args) {
HashMap annuaire= new HashMap();
String numero;
annuaire.put("Durand", "04.93.77.18.00");
annuaire.put("Dupuy", "04.93.66.38.76");
annuaire.put("Leroy", "04.92.94.20.00");
numero = (String)annuaire.get("Durand");
annuaire.remove("Durand");
System.out.println ("Annuaire= " + annuaire);
}
}
2. Exploiter un dictionnaire :
public static double moyenne(final HashMap notes) {
double total= 0;
Object matiere= null;
Iterator i= notes.keySet().iterator();
while (i.hasNext()) {
matiere= i.next();
total += ((Double)notes.get(matiere)).doubleValue();
}
return total / notes.size());
}
3. Dupliquer un dictionnaire (même problème qu’avec la liste) :
HashMap annuaire= new HashMap();
HashMap copie;
…
copie= (HashMap)annuaire.clone();
Permet d’accéder à
l’élément (via la clef)
Permet de visualiser
le dictionnaire
Permet
supprimer
un élément
(via la clef)

Générique :
Définition du concept :
- Dont le type et/ou la composition n’est pas arrêté.
- Dont la génération de code exécutable est paramétrée.
- Dont la composition et/ou l’organisation peut varier suivant les exécutions.
Objectifs de la généricité :
 Retarder la description complète d’un modèle
- Modèle de données (collections, classes).
- Modèle de traitement (méthodes).
Nouveautés :
 La boucle for each :
for(<type> <var> :<collection>) {instructions}
Forme simplifiée pour le parcours des collections et permet de masquer l’usage des itérateurs.
Exemples :
- for (int val : notes) resultat += val;
- ArrayList lesValeurs= new ArrayList();
lesValeurs.add("bleu");
lesValeurs.add("vert");
lesValeurs.add("jaune");
for (String v : lesValeurs)
System.out.println(v);
 Collection avec typage générique
Permet ainsi d’indiquer au compilateur de quel type seront les objets constituant la collection,
de cette manière le programme ne pourra compiler si on essaye d’introduire une instance d’une
autre classe dans la collection et le transtypage sera fait implicitement.
Sans usage du typage générique
Avec usage du typage générique
public static float moyenne(LinkedList notes) {
float somme=0.0f;
Iterator i= notes.iterator();
while (i.hasNext()) somme += (Float)i.next();
return somme/notes.size();
}
public static float moyenne(LinkedList <Float>notes) {
float somme=0.0f;
for (float val : notes) somme += val;
return somme/notes.size();
}

Exemple d’une classe composée d’un dictionnaire associant un String et un autre dictionnaire
(associant un String et d’un tableau de Float) :
import java.util.HashMap;
import java.util.Iterator;
public class CO2 {
private HashMap<String, HashMap<String, Float[]>> mesures;
public CO2 () {
mesures=null;
}
public CO2 (HashMap<String, HashMap<String, Float[]>> x) {
mesures=x;
}
float moyenneRegion (String uneRegion) throws Throwable {
float somme=0.0f;
float moyenne=0.0f;
String ville="";
HashMap<String, Float[]> h=null;
if (equals(null))
throw new Throwable("-2.1");
if (mesures.containsKey(uneRegion)==false)
throw new Throwable("-3.1");
if (mesures.get(uneRegion).equals(null))
throw new Throwable("-3.2");
h=(HashMap<String, Float[]>)mesures.get(uneRegion);
Iterator i= h.keySet().iterator();
while (i.hasNext())
{
ville = (String)i.next();
Float[] tab=h.get(ville);
for(int y=0;y<tab.length;y++){
somme+=tab[y];
}
somme=somme/tab.length;
moyenne+=somme;
somme=0.0f;
}
return moyenne/h.size();
}