lims Hubbard
22/06/06
12:33
Page 1
STRUCTURES DE DONNÉES EN JAVA J. R. HUBBARD Professeur de mathématiques et d’informatique à l’université de Richmond (Virginie, USA)
Traduit de l’américain par Virginie Maréchal
lims Hubbard
22/06/06
12:33
Page 2
Ce pictogramme mérite une explication. Son objet est d’alerter le lecteur sur la menace que représente pour l’avenir de l’écrit, particulièrement dans le domaine de l’édition technique et universitaire, le développement massif du photocopillage. Le Code de la propriété intellectuelle du 1er juillet 1992 interdit en effet expressément la photocopie à usage collectif sans autorisation des ayants droit. Or, cette pratique s’est généralisée dans les
établissements d’enseignement supérieur, provoquant une baisse brutale des achats de livres et de revues, au point que la possibilité même pour les auteurs de créer des œuvres nouvelles et de les faire éditer correctement est aujourd’hui menacée. Nous rappelons donc que toute reproduction, partielle ou totale, de la présente publication est interdite sans autorisation du Centre français d’exploitation du droit de copie (CFC, 20 rue des GrandsAugustins, 75006 Paris).
Original edition copyright © 2001 by The McGraw-Hill Companies, Inc. All rights reserved. L’édition originale de cet ouvrage est parue sous le titre : Schaum’s Outline of Data Structures with Java.
© Dunod, Paris, 2003, pour l’édition française. Tous droits réservés. ISBN : 2-10-0006937-3
Toute représentation ou reproduction intégrale ou partielle faite sans le consentement de l’auteur ou de ses ayants droit ou ayants cause est illicite selon le Code de la propriété intellectuelle (Art L 122-4) et constitue une contrefaçon réprimée par le Code pénal. • Seules sont autorisées (Art L 122-5) les copies ou reproductions strictement réservées à l’usage privé du copiste et non destinées à une utilisation collective, ainsi que les analyses et courtes citations justifiées par le caractère critique, pédagogique ou d’information de l’œuvre à laquelle elles sont incorporées, sous réserve, toutefois, du respect des dispositions des articles L 122-10 à L 122-12 du même Code, relatives à la reproduction par reprographie.
Sommaire
Avant-propos Chapitre 1
IX Caractéristiques de base du langage java 1.1 Programmation orientée objet 1.2 Langage de programmation Java 1.3 Variables et objets 1.4 Types primitifs 1.5 Contrôle du flux 1.6 Classes 1.7 Modificateurs 1.8 Classe String 1.9 Classe Math Questions de révision Réponses Exercices d’entraînement Solutions
Chapitre 2
Caractéristiques de base des tableaux 2.1 Propriétés des tableaux 2.2 Copier un tableau 2.3 Classe Arrays 2.4 Algorithme de recherche séquentielle 2.5 Algorithme de recherche binaire 2.6 Classe Vector Questions de révision Réponses Exercices d’entraînement Solutions
Chapitre 3
Java avancé 3.1 3.2 3.3 3.4 3.5
Héritage Polymorphisme Conversion des types Classe Object Classes abstraites
1 1 1 2 3 5 7 9 10 13 16 17 18 20 25 25 27 28 31 33 35 38 39 39 44 57 57 58 60 62 64
IV
Chapitre 4
Structures de données en Java
3.6 Interfaces 3.7 Paquetages 3.8 Gérer les exceptions Questions de révision Réponses Exercices d’entraînement Solutions
67 70 70 72 72 73 74
Récursivité
77 78 79 80 82 83 83 84 85 85 87 88 89 89 92
4.1 La base et la partie récursive de la récursivité 4.2 Tracer un appel récursif 4.3 Algorithme récursif de recherche binaire 4.4 Coefficients binomiaux 4.5 Algorithme d’Euclide 4.6 Preuve inductive de correction 4.7 Analyse de la complexité des algorithmes récursifs 4.8 Programmation dynamique 4.9 Les tours de Hanoi 4.10 Récursivité mutuelle Questions de révision Réponses Exercices d’entraînement Solutions
Chapitre 5
Collections 5.1 Framework de collections Java 5.2 Interface Collection 5.3 Classe AbstractCollection 5.4 Classe Bag 5.5 Interface Iterator Questions de révision Réponses Exercices d’entraînement Solutions
Chapitre 6
Piles 6.1 Classe Java Stack 6.2 Applications des piles 6.3 Supprimer la récursivité Questions de révision Réponses Exercices d’entraînement Solutions
99 99 100 101 102 109 109 110 110 111 115 115 118 121 122 122 123 125
V
Sommaire
Chapitre 7
Files 7.1 Framework des files 7.2 Implémentation contiguë 7.3 Implémentation chaînée 7.4 Applications utilisant les files Questions de révision Réponses Exercices d’entraînement Solutions
Chapitre 8
Listes 8.1 Interface java.util.List 8.2 Implémenter l’interface java.util.List 8.3 Classes AbstractList et AbstractSequentialList 8.4 Itérateurs de listes 8.5 Classe ArrayList 8.6 Classe LinkedList 8.7 Itérateurs de listes indépendants Questions de révision Réponses Exercices d’entraînement Solutions
Chapitre 9
Arbres 9.1 Terminologie des arbres 9.2 Arbres décisionnels et diagrammes de transition 9.3 Arbres ordonnés 9.4 Algorithmes de parcours des arbres ordonnés Questions de révision Réponses Exercices d’entraînement Solutions
Chapitre 10
Arbres binaires 10.1 10.2 10.3 10.4 10.5 10.6 10.7 10.8 10.9
Terminologie Compter les arbres binaires Arbres binaires complets Identité, égalité et isomorphisme Arbres binaires parfaits Algorithmes de parcours des arbres binaires Arbres d’expression Classe BinaryTree Implémenter les algorithmes de parcours
129 129 132 134 136 142 142 142 144 149 149 151 151 153 154 155 164 165 165 166 167 171 172 174 177 178 180 181 183 183 187 187 188 189 190 192 194 196 198 203
VI
Chapitre 11
Structures de données en Java
10.10 Forêts Questions de révision Réponses Exercices d’entraînement Solutions
205 206 207 208 210
Arbres de recherche
217 217 219 222
11.1 11.2 11.3 11.4
Arbres de recherche multidirectionnels Arbres équilibrés ou arbres-B Arbres binaires de recherche Caractéristiques des arbres binaires de recherche en matière de performances 223 11.4 Arbres AVL 11.6 Classe AVLTree Questions de révision Réponses Exercices d’entraînement Solutions
Chapitre 12
Tas et files de priorité 12.1 Tas 12.2 Mappage naturel 12.3 Insérer des éléments dans un tas 12.4 Supprimer un élément d’un tas 12.5 Classe PriorityQueue 12.6 Interface Java Comparator 12.7 Implémentation directe Questions de révision Réponses Exercices d’entraînement Solutions
Chapitre 13
Algorithmes de tri 13.1 13.2 13.3 13.4 13.5 13.6 13.7 13.8 13.9 13.10 13.11
Méthode Java Arrays.sort() Tri par permutation Tri par sélection Tri par insertion Tri Shell Tri par fusion Tri par segmentation Tri vertical Rapidité des algorithmes de tri par comparaison Tri digital Tri panier
224 225 227 228 228 229
233 233 233 234 235 236 237 239 243 243 244 245 251 252 252 254 255 256 258 260 263 268 268 270
VII
Sommaire
Chapitre 14
Questions de révision Réponses Exercices d’entraînement Solutions
272 274 275 277
Tables
287 287 288 289 290 292 293 295 296 298 300 300 301 302
14.1 Interface Java Map 14.2 Classe HashMap 14.3 Codes de hachage Java 14.4 Tables de hachage 14.5 Performances des tables de hachage 14.6 Algorithmes de résolution des collisions 14.7 Chaînage séparé 14.8 Applications 14.9 Classe TreeMap Questions de révision Réponses Exercices d’entraînement Solutions
Chapitre 15
Ensembles 15.1 Ensembles mathématiques 15.2 Interface Java Set 15.3 Classe Java AbstractSet 15.4 Classe Java HashSet 15.5 Classe Java TreeSet Questions de révision Réponses Exercices d’entraînement Solutions
Chapitre 16
Graphes 16.1 16.2 16.3 16.4 16.5 16.6 16.7 16.8 16.9 16.10 16.11 16.12
Graphes simples Terminologie des graphes Chemins et cycles Graphes isomorphes Matrice d’adjacence d’un graphe Matrice d’incidence d’un graphe Liste d’adjacences d’un graphe Digraphes Chemins d’un digraphe Digraphes pondérés et graphes Chemins et cycles eulériens et hamiltoniens Algorithme de Dijkstra
305 305 306 306 307 309 311 311 311 312 313 313 313 314 316 318 319 319 320 321 322 323 324
VIII
Annexes
Index
Structures de données en Java
16.13 Algorithmes de parcours des graphes Questions de révision Réponses Exercices d’entraînement Solutions
328 332 332 333 338
A. Mathématiques de base
345
B. De C++ à Java
366
C. Environnements de développement Java
368 371
Avant-propos
Comme tous les livres de notions fondamentales proposés dans la série Schaum’s, celui-ci est en premier lieu destiné aux personnes qui souhaitent étudier seules, de préférence en complément d’un cours sur les structures de données. Il constitue également une excellente référence pour les programmeurs Java plus expérimentés. Cet ouvrage comprend plus de 260 exemples et exercices d’entraînement. L’auteur est convaincu que les principes des structures de données peuvent être acquis plus aisément grâce à un large éventail d’exemples bien structurés et accompagnés d’explications précises. Ce livre est conçu de façon à apporter cette aide au lecteur. Le code source des exemples et les exercices peuvent être téléchargés depuis le site web de l’auteur http://www.mathcs.richmond.edu/~hubbard/Books.html. Toutes les corrections et les addenda sont également disponibles sur ce site. Je souhaiterais remercier tous mes amis, collègues, étudiants dont les critiques constructives m’ont été d’une aide précieuse. Je tiens tout particulièrement à remercier ma femme, Anita Hubbard, pour ses conseils, ses encouragements et les exemples créatifs qu’elle a apportés à ce livre. La plupart des idées originales que vous y trouverez sont d’elle. JOHN R. HUBBARD Richmond, Virginie
[email protected]
Chapitre 1
Caractéristiques de base du langage java Ce chapitre est consacré aux fonctionnalités de base du langage de programmation Java nécessaires à la conception et l’implémentation des structures de données.
1.1 PROGRAMMATION ORIENTÉE OBJET Java est un langage de programmation orienté objet parce qu’il présente les caractéristiques suivantes : • • • •
Chaque élément de donnée est encapsulé dans un objet. Chaque instruction exécutable est effectuée par un objet donné. Chaque objet est l’instanciation d’une classe ou est un tableau. Chaque classe est définie dans le cadre d’une hiérarchie d’héritage unique. La hiérarchie d’héritage unique de Java est une structure arborescente dont la racine est la classe
Object (reportez-vous à la section 3.4). Même si cette structure peut vous faire penser que Java est un
langage simple, ne vous fiez pas aux apparences car elle comprend les bibliothèques de classes Java 1.3 qui sont composées de 2 130 classes et de 23 901 membres. Ce sont ces caractéristiques orientées objet qui font de Java un langage particulièrement adapté à la conception et à l’implémentation des structures de données. L’architecture de ses collections (reportezvous au chapitre 4) offre une plate-forme idéale de construction des structures de données.
1.2 LANGAGE DE PROGRAMMATION JAVA Un programme Java est une collection d’un ou de plusieurs fichiers texte. Au moins l’un de ces fichiers contient une classe publique unique avec une méthode unique dont la signature est la suivante : public static void main(String[] args)
Chaque fichier du programme doit comprendre une classe ou bien une interface publique et est appelé X.java, X correspondant au nom de la classe ou de l’interface publique unique. Chaque fichier X.java est compilé dans un fichier classe appelé X.class. Le programme est ensuite lancé en exécutant le fichier X.class qui contient la méthode main(String[]) comprenant les instructions à exécuter.
2
Caractéristiques de base du langage java
Cette programmation peut être effectuée à partir de la ligne de commande ou bien d’un environnement IDE (reportez-vous à l’annexe C).
1.3 VARIABLES ET OBJETS Dans le cadre de tous les langages de programmation, l’accès aux données est effectué via les variables. Avec Java, une variable est soit une référence à un objet, soit l’un des huit types primitifs, comme illustré dans le diagramme. S’il s’agit d’une référence, sa valeur est null ou bien elle contient l’adresse d’un objet instancié. Chaque objet appartient à une classe unique qui définit les propriétés et les opérations de ses objets de la même manière qu’un type primitif définit les propriétés et les opérations de ses variables. Une variable est créée par une déclaration spécifiant son type et sa valeur initiale facultative. Un objet est créé par l’opérateur new qui appelle son constructeur de classe.
Types Java Types primitifs
boolean Types numériques Types entiers
byte short int long char Types à virgule flottante
float double Types de références type Tableau type Classe type Interface
Exemple 1.1 Créer des variables et des objets public class Ex0101 { public static void main(String[] args) { boolean flag=true; char ch=’B’; short m; int n=22; float x=3.14159F; double y; String str; String nada=null; String pays = new String("France"); System.out.println("flag = " + flag); System.out.println("ch = " + ch); System.out.println("n = " + n); System.out.println("x = " + x); System.out.println("nada = " + nada); System.out.println("pays = " + pays); } } flag = true ch = B n = 22 x = 3,14159 nada = null pays = France
Ce programme déclare neuf variables, puis il imprime les six qui ont été initialisées. Les six premières variables sont de type primitif et les trois dernières sont des références aux objets String. Il contient un seul objet qui est de type String et s’appelle pays (techniquement, pays est le nom de la variable faisant référence à l’objet String).
3
Types primitifs
La figure présentée contient les neuf variables et le seul objet. Chacune de ces variables a un nom et un type. Si le type est une classe, la variable est une référence à une instance (c’est-à-dire à un objet) de cette classe. Les variables non initialisées sont vides, tandis que les autres contiennent une valeur. Une variable de référence ne peut contenir qu’une seule valeur, c’est-à-dire la référence dessinée sous forme d’un point noir. Si cette référence n’est pas null, le point est composé d’une flèche pointant vers l’objet auquel il fait référence. En Java, un objet ne peut pas exister si une variable de référence ne pointe pas vers lui.
flag
true
ch
"B"
boolean
m
char
n
22
short
x
3.14159
int
y
float
str String
pays
double
nada String
"France"
String
1.4 TYPES PRIMITIFS Le langage Java définit les huit types primitifs suivants : • • • • • • • •
boolean false ou true
caractère Unicode 6 bits char, soit ’B’ ou ’π’ entier 8 bits byte : –128 à 127 entier 16 bits short : –32768 à 32767 entier 32 bits int : –2147483648 à 2147483647 entier 64 bits long : –9223372036854775808 à 9223372036854775807 nombre décimal à virgule flottante 32 bits float : (plus ou moins) 1.4E-45F à 3.4E38F nombre décimal à virgule flottante 64 bits double : (plus ou moins) 4.9E-324 à 1.8E308
Remarquez que les littéraux de type float doivent être précédés du suffixe F qui les différencie des valeurs de type double. Chaque littéral Unicode peut être exprimé sous la forme '\uxxxx', x correspondant à un chiffre hexadécimal. Par exemple, 'B' correspond à '\u0042' et 'π' à '\u03C0'. Outre leur valeur numérique, les variables à virgule flottante peuvent également contenir l’une des trois valeurs spéciales suivantes : NEGATIVE_INFINITY, POSITIVE_INFINITY et NaN (Not a Number, c’est-à-dire « n’est pas un nombre »). Ces valeurs spéciales sont obtenues à la suite de mauvaises opérations arithmétiques.
Exemple 1.2 Valeurs spéciales des types à virgule flottante public class Ex0102 { public static void main(String[] args) { double x=1E200; // x=10000...0 (1 suivi de 200 zéros) System.out.println("x = " + x); System.out.println("x*x = " + x*x); System.out.println("(x*x)/x = " + (x*x)/x); System.out.println("(x*x)/(x*x) = " + (x*x)/(x*x)); } } x = 1.0E200 x*x = Infinity (x*x)/x = Infinity (x*x)/(x*x) = NaN
4
Caractéristiques de base du langage java
La valeur de x*x est Infinity parce que (10200)(10200) == 10400, soit une valeur supérieure au maximum de 1.3(10308) pour le type double. D’un point de vue algébrique, (xx)/x = x, sauf lorsque x est fini. En effet, Infinity divisé par une valeur finie non négative sera toujours Infinity. En dernier lieu, la valeur Infinity divisée par Infinity ne produit pas de valeur finie, mais une valeur indéterminée sur le plan algébrique, d’où la valeur Java NaN. Pour chacun des huit types primitifs, Java définit une classe enveloppe qui fournit les services orientés objets nécessaires à la manipulation des types primitifs. Par exemple, la classe enveloppe du type double est Double, et celle du type int est Integer.
Exemple 1.3 Utiliser une classe enveloppe public class Ex0103 { public static void main(String[] args) { String s = "2.7182818284590"; System.out.println("s = " + s); Double x = new Double(s); System.out.println("x = " + x); double y = x.doubleValue(); System.out.println("y = " + y); s += 45; System.out.println("s = " + s); y += 45; System.out.println("y = " + y); int n = x.intValue(); System.out.println("n = " + n); n = Integer.parseInt("3A9",16); System.out.println("n = " + n); } } s x y s y n n
= = = = = = =
2.7182818284590 2.718281828459 2.718281828459 2.718281828459045 47.718281828459 2 937
Le constructeur Double(s) crée l’objet x de type Double à partir de l’objet s de type String et il stocke la valeur numérique 2.7182818284590 dans l’objet x. La deuxième instruction println() appelle implicitement la méthode Double.toString() qui reconvertit cette valeur numérique en chaîne à imprimer. L’appel x.doubleValue() renvoie la valeur numérique stockée affectée à y. L’opérateur += est ensuite appliqué à l’objet s de type String et à la variable y de type double, créant ainsi des résultats complètement différents. Dans le cas des chaînes, += signifie « insérer » alors qu’il signifie « additionner » lorsqu’il s’agit de numéros. Puis, la méthode Double.intValue() tronque la valeur numérique stockée de l’entier 2 et l’utilise pour initialiser n. En dernier lieu, Integer.parseInt("3A9",16) renvoie la valeur int (au format décimal) pour l’entier dont la représentation hexadécimale est 3A9, soit 3(162) + 10(16) + 9 = 937. Remarquez que l’opérateur + convertit automatiquement le nombre y en son équivalent de type chaîne lorsqu’il est combiné à une chaîne, comme c’est le cas pour l’appel System.out .println("y = " + y).
Contrôle du flux
5
1.5 CONTRÔLE DU FLUX Le langage Java supporte les instructions if, if..else et switch, ainsi que l’opérateur d’expression conditionnelle ?..:.
Exemple 1.4 Utiliser les instructions conditionnelles Le programme suivant génère des entiers aléatoires dans un intervalle de 0 à 99, puis il utilise les instructions conditionnelles afin de les classer : public class Ex0104 { public static void main(String[] args) { int n = (int)Math.round(100*Math.random()); System.out.println("n = " + n); if (n>25 && n<75) System.out.println(n + " est compris entre 25 et 75"); else System.out.println(n + " n’est pas compris entre 25 et 75"); switch ((int)n/20) { case 0: System.out.println(n + " < 20"); case 1: System.out.println(n + " < 40"); case 2: System.out.println(n + " < 60"); break; case 3: System.out.println(n + " < 80"); break; default: System.out.println(n + " >= 80"); } System.out.println(n + (n%2>0 ? " est impair" : " est pair")); } } n = 19 19 n’est pas compris entre 25 et 75 19 < 20 19 < 40 19 < 60 19 est impair
Remarquez que l’absence d’instruction break entre case 0 et case 1 permet au contrôle de traverser chacun de ces cas jusqu’à la case 2 et d’exécuter les trois instructions println(). L’expression (n%2>0 ? " est impair" : " est pair") est évaluée à la chaîne " est impair" si la condition n%2>0 est vraie (c’est-à-dire si n n’est pas divisible par 2). Dans le cas contraire, elle est évaluée à la chaîne " est pair" (lorsque n est divisible par 2). Java supporte les instructions while, do..while et for.
Exemple 1.5 Utiliser les boucles Le programme teste empiriquement le théorème des nombres premiers de Gauss : si p(n) est le nombre de nombres premiers inférieurs à n, le rapport p(n)(ln n)/n se rapproche de 1.0 lorsque n devient illimité. Il compte le nombre p(n) de nombres premiers pour chaque n impair situé dans l’intervalle 3 à 1 000 000. Au fur et à mesure de l’augmentation de p(n), chaque fois qu’un multiple de 5 000 est passé, le programme imprime les valeurs de n, p(n), lnn (le logarithme naturel) et le rapport p(n)(ln n)/n, soit un nombre proche de 1.0. public class Ex0105 { public static void main(String[] args) { System.out.println("n\tp(n)\tln(n)\t\t\tp(n)*ln(n)/n"); final String DASHES18="\t------------------"; System.out.println("------\t-----" + DASHES18 + DASHES18);
6
Caractéristiques de base du langage java
int p=1; // p = nombre de nombres premiers qui sont <= n for (int n=3; n<1000000; n += 2) { int d=3; while (d<=Math.sqrt(n) && n%d>0) d += 2; if (n%d==0) continue; ++p; if (p%5000>0) continue; double ln=Math.log(n); System.out.println(n + "\t" + p + "\t" + ln + "\t" + p*ln/n); } System.out.println("------\t-----" + DASHES18 + DASHES18); } } n -----48619 104743 163847 224743 287137 350381 414991 479939 545749 611957 679279 746777 814309 882389 951193 ------
c(n) -----5000 10000 15000 20000 25000 30000 35000 40000 45000 50000 55000 60000 65000 70000 75000 ------
ln(n) -----------------10.79176967999097 11.559265009775785 12.006688344529985 12.322712806131365 12.567714732761953 12.766776412829921 12.936012112230687 13.08141429147497 13.209914442069696 13.324417297588104 13.428787220525182 13.52352189210366 13.610095179831822 13.690388280841916 13.765472265206315 -------------------
c(n)*ln(n)/n -------------------1.109830486023054 1.1035835339617717 1.0991981859170432 1.0966048158235286 1.0942263390613152 1.093105198012728 1.091012633835611 1.0902564110418174 1.0892299388420983 1.0886726761511107 1.087304770394617 1.0865510232990836 1.0863888114819662 1.0860597533048737 1.085384795609801 ------------------
La boucle for est itérée 499 999 fois, soit pour chaque valeur de n = 3, 5, 7, 9, …, 999999. Le bloc de la boucle teste si n est un nombre premier en le divisant par d = 3, 5, 7, 9, etc. S’il trouve un nombre d qui divise n de façon à ce que le reste n%d soit égal à zéro, la première instruction continue est exécutée, en commençant par l’itération suivante de la boucle for. En revanche, si aucun diviseur de n n’est trouvé, cela signifie qu’il s’agit d’un nombre premier et le compteur p est alors incrémenté. Java supporte l’utilisation de sous-programmes appelés méthodes.
Exemple 1.6 Utiliser des méthodes Le programme suivant crée la même sortie que celui de l’exemple précédent même s’il utilise une méthode séparée pour déterminer si chaque entier n est un nombre premier. public class Ex0106 { public static void main(String[] args) { System.out.println("n\tp(n)\tln(n)\t\t\tp(n)*ln(n)/n"); final String DASHES18="\t------------------"; System.out.println("------\t-----" + DASHES18 + DASHES18); int p=1; // p = nombre de nombres premiers <= n for (int n=3; n<1000000; n += 2) if (isPrime(n)) { ++p; if (p%5000>0) continue;
7
Classes
double ln=Math.log(n); System.out.println(n + "\t" + p + "\t" + ln + "\t" + p*ln/n); } System.out.println("------\t-----" + DASHES18 + DASHES18); } private static boolean isPrime(int n) { int d=3; while (d<=Math.sqrt(n) && n%d>0) d += 2; if (n%d==0) return false; return true; } }
La méthode isPrime(s) encapsule le code qui teste si n est un nombre premier. Elle renvoie false si un diviseur d de n est trouvé, et true dans le cas contraire. Remarquez que cette méthode est déclarée comme étant privée et statique. Elle doit être privée parce qu’elle n’est pas destinée à être utilisée hors de sa classe, et statique parce qu’elle doit être appelée depuis la méthode statique main() (reportez-vous à la section 1.7).
1.6 CLASSES Une classe est une implémentation d’un type de données abstrait. Les objets sont créés grâce à l’instanciation des classes. La définition d’une classe spécifie le type de données géré par ses objets et les opérations que ces derniers peuvent effectuer. Ces spécifications correspondent aux membres de la classe. Comme illustré dans la figure, quatre types de membres peuvent commembre poser une classe. champ Un champ est une variable qui contient des données. Une méthode est méthode et une fonction qui effectue des opérations. À l’intérieur d’elle-même, une constructeur ns r classe peut également définir des classes et des interfaces locales internes. ce accesseur En outre, la figure précédente contient quatre types courants de méthot mutateur des spécialisées : les constructeurs, les accesseurs, les mutateurs et les utit utilitaire litaires. Un constructeur est une fonction qui crée les objets de la classe. Ce classe processus est qualifié d’instanciation et les objets obtenus d’instances de la interface classe. Le constructeur est également chargé d’initialiser les champs des objets qu’il crée. Un accesseur est une fonction en lecture seule qui peut renvoyer la valeur d’un champ de classe sans permettre sa modification externe. Dans le cadre de Java, un accesseur qui accède à un champ X est généralement appelé getX(). C’est la raison pour laquelle les accesseurs sont souvent qualifiés de getters. Un mutateur est en lecture-écriture et permet aux appeleurs externes de modifier la valeur d’un champ. Dans le cadre de Java, un mutateur qui modifie un champ X est généralement appelé setX(). C’est la raison pour laquelle les mutateurs sont souvent qualifiés de setters. Un utilitaire est une fonction privée utilisée de façon interne par d’autres méthodes de la classe.
Exemple 1.7 Classe Point Le programme suivant définit une classe dont les instances représentent des points d’un plan euclidien : public class Point { protected double x, y; public Point(double x, double y)
8
Caractéristiques de base du langage java
{ this.x = x; this.y = y; } public double getX() { return x; } public double getY() { return y; } public Point getLocation() { return new Point(x,y); } public void setLocation(double x, double y) { this.x = x; this.y = y; } public void translate(double dx, double dy) { x += dx; y += dy; } public boolean equals(Object object) { if (object == this) return true; if (object.getClass() != this.getClass()) return false; Point point = (Point)object; return (x == point.x && y == point.y); } public int hashCode() { return (new Double(x)).hashCode() + (new Double(y)).hashCode(); } public String toString() { return new String("(" + (float)x + "," + (float)y + ")"); } }
Cette classe a trois champs (x, y et origin), un constructeur et cinq accesseurs (getX(), getY(), getLocation(), hashCode() et toString()), et un mutateur (translate(double, double)). Le pilote test de cette classe est le suivant : public class Ex0107 { public static void main(String[] args) { Point p = new Point(2,3); System.out.println("p = " + p); System.out.println("p.hashCode() = " + p.hashCode()); Point q = p.getLocation(); compare(p,q); q.translate(5,-1); compare(p,q); q = p; compare(p,q); } private static void compare(Point p, Point q) { System.out.println("q = " + q);
Modificateurs
9
System.out.println("q.hashCode() = " + q.hashCode()); if (q.equals(p)) System.out.println("q est égal à p"); else System.out.println("q n’est pas égal à p"); if (q == p) System.out.println("q == p"); else System.out.println("q != p"); } } p = (2.0,3.0) p.hashCode() = -2146959360 q = (2.0,3.0) q.hashCode() = -2146959360 q est égal à p q != p q = (7.0,2.0) q.hashCode() = -2145648640 q n’est pas égal à p q != p q = (2.0,3.0) q.hashCode() = -2146959360 q est égal à p q == p
Ce pilote test comprend la méthode utilitaire compare(Point,Point) qui facilite la vérification. Le point p a la valeur hashCode() –2 146 959 360. Ce nombre n’a aucune signification intrinsèque, il x 2.0 y 3.0 p est simplement utilisé comme numéro d’identificadouble double Point tion et est calculé à partir des valeurs hashcode() correspondantes des deux objets de coordonnées du y 3.0 x 2.0 q point (x et y). double double Point Le point q est défini comme la copie de p. Il a donc la même valeur hashCode() et la méthode equals(Object) renvoie true. Cependant, le test q == p est évalué à false parce que p et q sont des x 7.0 y 2.0 q objets différents. En fait, l’opérateur d’égalité == double double Point teste plus l’identité que l’égalité, ce qui est vrai uniquement lorsque vous avez deux références différentes au même objet. x 2.0 y 3.0 Une fois que q est traduit à l’emplacement (7,2), la p double double Point méthode equals(Object) renvoie false. En dernier lieu, lorsque la référence p est affectée à q la référence q, l’égalité q == p est évaluée à true Point parce qu’il ne reste plus qu’un seul objet Point, soit le point d’origine (2,3). L’autre point (7,2) a été récupéré par le ramasse-miettes, c’est-à-dire qu’il a été détruit au moment où il a perdu sa variable de référence.
1.7 MODIFICATEURS Les classes, les interfaces et leurs membres peuvent être déclarés à l’aide des modificateurs public, protected, private, package, abstract, static et final. Le tableau suivant résume leur signification.
10
Caractéristiques de base du langage java
Modificateur Interface public
Classe
Classe imbriquée
Champ
Méthode
Accessible depuis n’importe quelle classe.
protected Accessible uniquement depuis cette classe et ses sous-classes. private
Accessible uniquement depuis cette classe.
abstract
Contient au moins une Sans objet méthode abstract.
final
Sans objet
static
Sans objet Sans objet
Ne peut pas être décomposée en sous-classes. N’est pas une classe interne.
Sans objet
Son implémentation n’est pas définie ; seuls sa signature et son type de renvoi sont déclarés.
Sa valeur ne peut pas être modifiée.
Ne peut pas être remplacée par une sous-classe.
Une seule instance existe pour tous les objets de la classe.
Une seule instance existe pour tous les objets de la classe.
Les modificateurs public, protected et private sont qualifiés de modificateurs d’accès parce qu’ils déterminent l’emplacement à partir duquel il est possible d’accéder à la classe ou au membre. Généralement, public signifie accessible depuis n’importe quel emplacement, protected signifie accessible uniquement depuis la classe et ses sous-classes et private signifie accessible uniquement depuis la classe elle-même. Un membre est déclaré comme abstract lorsqu’il est incomplet. C’est pourquoi une méthode abstract est une méthode dont l’implémentation n’est pas incluse. Une classe abstract comporte au moins une méthode abstract. Les interfaces sont abstract par défaut, c’est pourquoi elles n’utilisent pas de modificateur. Les champs ne peuvent pas être abstract. Une classe final ne peut pas être divisée en sous-classes (reportez-vous à la section 3.1). Un champ final est simplement une constante. Une méthode final ne peut pas être remplacée dans une sous-classe. Un champ static appartient à la classe elle-même ; il ne génère pas de copie séparée de chacune de ses instances. De la même façon, une méthode static est liée à la classe et non à ses objets. Si X est une classe avec un champ statique x et une méthode statique y(), X.x et X.y() permettent d’y accéder et sont indépendants des objets. La classe java.lang.Math (reportez-vous à la section 1.9) illustre l’utilisation des méthodes static.
1.8 CLASSE String Une chaîne (string) est un objet qui contient une séquence de caractères généralement utilisée pour traiter du texte. Java fournit une classe String qui permet la création et le traitement des chaînes. Cette classe contient plus de 50 méthodes, dont plus de 10 constructeurs. Vous trouverez les méthodes les plus couramment utilisées dans la définition de classe suivante. Bien que les chaînes soient des objets et non des types primitifs, elles sont similaires à ces derniers sur certains points. Le système reconnaît les littéraux de chaînes tels que "bleu" et "automne", de la même façon qu’il reconnaît des littéraux numériques tels que 8388608 et 3,14159. En outre, les références de chaîne peuvent être affectées à ces littéraux de la façon suivante : String couleur="bleu";
Classe String
11
Étant donné que les littéraux sont uniques, toute autre référence à "bleu" sera évaluée comme égale à la référence couleur. À l’instar des types numériques, les chaînes sont les seules classes d’objets susceptibles d’être manipulées par des opérateurs (reportez-vous à l’exemple 1.8). public final class String { public char charAt() public boolean endsWith(String suffix) public boolean equals(Object object) public int indexOf(char ch) public int indexOf(char ch, int start) public int indexOf(String str) public int indexOf(String str, int start) public int lastIndexOf(char ch) public int lastIndexOf(char ch, int start) public int lastIndexOf(String str) public int lastIndexOf(String str, int start) public int length() public String replace(char ch, char ch2) public boolean startsWith(String prefix) public boolean startsWith(String prefix, int start) public String() public String(char[] chars) public String(char[] chars, int start, int len) public String substring(int start) public String substring(int start, int stop) public char[] toCharArray() public String toLowerCase() public String toUpperCase() public String trim() }
Par ailleurs, la classe String définit les deux opérateurs de concaténation + et += illustrés dans l’exemple suivant.
Exemple 1.8 Tester la classe String public class Ex0108 { public static void main(String[] args) { String s="ABCDEFG"; System.out.println("s = \"" + s + "\""); s = s + "HIJK"; System.out.println("s = \"" + s + "\""); s += "LMNOP"; System.out.println("s = \"" + s + "\""); System.out.println("s.length() = " + s.length()); System.out.println("s.charAt(6) = " + s.charAt(6)); System.out.println("s.indexOf(’G’) = " + s.indexOf(’G’)); System.out.println("s.indexOf(’Z’) = " + s.indexOf(’Z’)); System.out.println("s.indexOf(’G’,8) = " + s.indexOf(’G’,8)); System.out.println("s.indexOf(\"GHIJ\") = " + s.indexOf("GHIJ")); if (s.startsWith("DE")) System.out.println("s.startsWith(\"DE\")"); else System.out.println("s ne commence pas par \"DE\""); if (s.startsWith("DE",3)) System.out.println("s.startsWith(\"DE\",3)"); else System.out.println("s ne commence pas par \"DE\" après 3 chars");
12
Caractéristiques de base du langage java
if (s.endsWith("IJK")) System.out.println("s.endsWith(\"IJK\")"); else System.out.println("s ne finit pas par \"IJK\""); if (s.endsWith("NOP")) System.out.println("s.endsWith(\"NOP\")"); else System.out.println("s ne finit pas par \"NOP\""); s += "DABBADABBADO"; System.out.println("s = \"" + s + "\""); s = s.replace(’B’,’T’); System.out.println("s = \"" + s + "\""); s = s.substring(7,10); System.out.println("s = \"" + s + "\""); s = s.toLowerCase(); System.out.println("s = \"" + s + "\""); s = " W XY Z "; System.out.println("s = \"" + s + "\""); System.out.println("s.length() = " + s.length()); s = s.trim(); System.out.println("s = \"" + s + "\""); System.out.println("s.length() = " + s.length()); } } s = "ABCDEFGHIJK" s = "ABCDEFGHIJKLMNOP" s.length() = 16 s.charAt(6) = G s.indexOf(’G’) = 6 s.indexOf(’Z’) = -1 s.indexOf(’G’,8) = -1 s.indexOf("GHIJ") = 6 s ne commence pas par "DE" s.startsWith("DE",3) s ne finit pas par "IJK" s.endsWith("NOP") s = "ABCDEFGHIJKLMNOPDABBADABBADO" s = "ATCDEFGHIJKLMNOPDATTADATTADO" s = "HIJ" s = "hij" s = " W XY Z " s.length() = 12 s = "W XY Z" s.length() = 7
Remarquez que les objets String sont immuables. C’est pourquoi la seule méthode de modification d’une chaîne consiste à lui affecter la valeur de renvoi d’une méthode, par exemple replace (char,char) qui permet de renvoyer une nouvelle chaîne. Avec Java, le système d’exploitation de l’ordinateur doit gérer un pool de littéraux de chaînes et s’assurer qu’il n’existe qu’une seule occurrence de tout littéral de chaîne utilisé, quel que soit l’environnement d’exécution. Ce procédé est similaire à celui qui s’applique aux littéraux numériques, à savoir qu’il n’existe qu’un seul nombre 27. C’est la raison pour laquelle l’opérateur d’égalité == fonctionne toujours « correctement » pour les chaînes.
Exemple 1.9 Tester si les littéraux String sont uniques public class Ex0109 { public static void main(String[] args)
Classe Math
13
{ String s1="ABCDEFG"; System.out.println("s1 = \"" + s1 + "\""); System.out.println("(s1 == \"ABCDEFG\") = " + (s1 == "ABCDEFG")); System.out.println("(s1 == \"ABCD\"+\"EFG\") = " + (s1 == "ABCD"+"EFG")); String s2="ABCDEFG"; // fait de s2 un synonyme de s1 System.out.println("s2 = \"" + s2 + "\""); System.out.println("(s1 == s2) = " + (s1 == s2)); s2 = new String("ABCDEFG"); // s2 fait maintenant référence à // un objet séparé System.out.println("s2 = \"" + s2 + "\""); System.out.println("(s1 == s2) = " + (s1 == s2)); System.out.println("s1.equals(s2) = " + s1.equals(s2)); } } s1 = "ABCDEFG" (s1 == "ABCDEFG") = true (s1 == "ABCD"+"EFG") = true s2 = "ABCDEFG" (s1 == s2) = true s2 = "ABCDEFG" (s1 == s2) = false s1.equals(s2) = true
Dans ce programme, vous pouvez constater qu’il n’existe qu’un seul littéral de chaîne "ABCDEFG" quel que soit son format. C’est pourquoi si deux références différentes (c’est-à-dire des références avec des noms différents) sont affectées au littéral, elles doivent être égales, c’est-à-dire que l’opérateur d’égalité == est évalué à true. Remarquez cependant que deux chaînes différentes peuvent avoir la même valeur de littéral. Le cas échéant, l’opérateur d’égalité est évalué à false, mais la méthode equals() renvoie tout de même true. Comparez ce résultat à celui de l’exemple 1.7. Les propriétés spéciales suivantes permettent de différencier la classe String de toutes les autres classes : • • • •
Les objets String sont immuables (en lecture seule) ; leur valeur ne peut pas être modifiée. Les littéraux String sont gérés dans un pool de chaînes par le système d’exploitation. La classe String définit des opérateurs spéciaux + et +=. Il est possible d’accéder à la longueur grâce à la méthode length() au lieu du champ length, comme dans le cas des tableaux, ou bien grâce à la méthode size() utilisée par les objets Collection.
1.9 CLASSE Math La classe Java Math définit les constantes et les méthodes mathématiques qui implémentent les fonctions mathématiques courantes. Sa définition dans le paquetage java.util est la suivante : public final class Math { public static final double E=2.7182818284590452354; public static final double PI=3.14159265358979323846; public static double abs(double x) // valeur absolue public static native double atan(double x) // arctangent public static native double ceil(double x) // plafond public static native double cos(double x) public static native double exp(double x) // base e
14
Caractéristiques de base du langage java
public public public public public public public public public public
static static static static static static static static static static
native double floor(double x) native double log(double x) // base e native double max(double x, double y) native double min(double x, double y) native double pow(double x, double y) // puissance synchronized double random() long round(double x) native double sin(double x) native double sqrt(double x) // racine carrée native double tan(double x)
}
Remarquez que tous ces membres sont static. Cela signifie qu’ils sont appelés à l’aide du préfixe Math au lieu de l’objet Math.
Exemple 1.10 Tester la classe Math public class Ex0110 { public static void main(String[] args) { final double PI=Math.PI; final double E=Math.E; System.out.println("E = " + E); System.out.println("Math.exp(1.0) = " + Math.exp(1.0)); System.out.println("PI = " + PI); System.out.println("4*Math.atan(1.0) = " + 4*Math.atan(1.0)); System.out.println("Math.cos(2*PI) = " + Math.cos(2*PI)); System.out.println("Math.sin(PI/2) = " + Math.sin(PI/2)); System.out.println("Math.tan(PI/4) = " + Math.tan(PI/4)); System.out.println("Math.log(E) = " + Math.log(E)); System.out.println("Math.abs(-13.579) = " + Math.abs (-1.579)); System.out.println("Math.floor(13.579) = " + Math.floor(13.579)); System.out.println("Math.ceil(13.579) = " + Math.ceil(13.579)); System.out.println("Math.round(13.579) = " + Math.round(13.579)); System.out.println("Math.pow(25.0,0.5) = " + Math.pow(25.0,0.5)); System.out.println("Math.sqrt(25.0) = " + Math.sqrt(25.0)); System.out.println("Math.random() = " + Math.random()); System.out.println("Math.random() = " + Math.random()); } } E = 2.718281828459045 Math.exp(1.0) = 2.7182818284590455 PI = 3.141592653589793 4*Math.atan(1.0) = 3.141592653589793 Math.cos(2*PI) = 1.0 Math.sin(PI/2) = 1.0 Math.tan(PI/4) = 0.9999999999999999 Math.log(E) = 1.0 Math.abs(-13.579) = 13.579 Math.floor(13.579) = 13.0 Math.ceil(13.579) = 14.0 Math.round(13.579) = 14 Math.pow(25.0,0.5) = 5.0 Math.sqrt(25.0) = 5.0 Math.random() = 0.9279776738566742 Math.random() = 0.4493770111566855
Notez l’erreur d’arrondi dans le calcul de Math.tan(PI/4) ; la valeur correcte serait très exactement 1.0.
15
Classe Math
Notez également que la méthode Math.round(double) renvoie un entier long au lieu d’un nombre décimal à virgule flottante double comme toutes les autres méthodes Math. La méthode Math.random() renvoie des nombres décimaux à virgule flottante de type double générés de façon aléatoire et distribués uniformément dans un intervalle de 0.0 à 1.0. L’exemple suivant permet de tester cette distribution.
Exemple 1.11 Tester la méthode Math.random() Ce programme génère 50 000 nombres aléatoires dans un intervalle de 0.0 à 1.0, puis il compte combien d’entre eux entrent dans les 100 sous-intervalles divisés de façon égale selon une longueur de 0.01. Il utilise un tableau frequency[] pour cumuler ces comptes. Par exemple, le nombre aléatoire x= 0.7294416115902632 est situé dans l’intervalle 0.72 x < 0.73, c’est pourquoi il est compté en incrémentant frequency[72]. public class Ex0111 { public static void main(String[] args) { final int SUBINTERVALS=100; final int TOTAL=50000; int[] frequency = new int[SUBINTERVALS]; for (int k=0; k<SUBINTERVALS; k++) frequency[k] = 0; for (int j=0; j
506 529 499 480 527 503 533 504 489 501
515 483 477 566 482 497 499 507 511 522
454 504 498 487 506 483 488 478 512 468
495 476 500 512 498 522 511 512 464 524
512 496 498 485 475 468 468 521 487 505
502 471 517 489 519 505 506 484 499 508
542 524 482 461 517 510 476 479 506 533
506 508 438 524 466 488 510 480 497 530
514 489 492 504 509 532 498 487 526 504
Si les 50 000 nombres étaient distribués uniformément et exactement, nous devrions en avoir 500 dans chaque sous-intervalle. Étant donné que ces 100 comptes de fréquence sont proches de 500, nous obtenons la preuve empirique que la méthode Math.random() crée effectivement une distribution uniforme.
Exemple 1.12 Tester la méthode Math.sqrt() Ce programme teste la méthode Math.sqrt() en comparant ses résultats à une méthode de racine carrée définie localement et en mettant au carré sa sortie. public class Ex0112 { public static void main(String[] args)
16
Caractéristiques de base du langage java
{ for (double x=50.0; x<60.0; x++) { double y=Math.sqrt(x); double z=sqrt(x); System.out.println(y + "\t" + y*y); System.out.println(z); } } private static double sqrt(double x) { final double EPSILON=1E-14; if (x <= 0) return 0.0; double y=1.0; while (Math.abs(y*y-x) > EPSILON) y = (y+x/y)/2; return y; } } 7.0710678118654755 7.0710678118654755 7.14142842854285 7.14142842854285 7.211102550927978 7.211102550927979 7.280109889280518 7.280109889280518 7.3484692283495345 7.3484692283495345 7.416198487095663 7.416198487095663 7.483314773547883 7.483314773547883 7.54983443527075 7.54983443527075 7.615773105863909 7.615773105863909 7.681145747868608 7.681145747868609
?
50.00000000000001 51.00000000000001 51.99999999999999 53.0 54.0 55.0 56.0 57.0 58.00000000000001 58.99999999999999
QUESTIONS DE RÉVISION
QUESTIONS DE RÉVISION
1.1
Pourquoi le langage de programmation Java est-il qualifié d’orienté objet ?
1.2
Quels sont les éléments nécessaires à l’écriture d’un programme Java ?
1.3
Qu’est-ce qu’un type primitif ?
1.4
Qu’est-ce qu’un littéral ?
1.5
Quels sont les trois littéraux non numériques des deux types à virgule flottante ?
1.6
Qu’est-ce qu’une référence d’objet ?
1.7
Qu’est-ce qu’un objet ?
1.8
Qu’est-ce qu’une classe ?
1.9
Qu’est-ce qu’une instance ?
Révision et entraînement
17
1.10 Qu’est-ce qu’un champ ? 1.11 Qu’est-ce qu’une méthode ? 1.12 Qu’est-ce que la signature d’une méthode ? 1.13 Qu’est-ce qu’un constructeur ? 1.14 Qu’est-ce qu’un membre static ? 1.15 Qu’est-ce qu’un modificateur d’accès ? 1.16 Que signifie private ? 1.17 Que signifie protected ? 1.18 Qu’est-ce qu’une classe enveloppe ? 1.19 Qu’est-ce qui différencie la classe String de toutes les autres classes de la bibliothèque Java
standard ? 1.20 À quoi sert la méthode Math.random() ?
¿
RÉPONSES
RÉPONSES
1.1
Java est qualifié de langage de programmation orienté objet parce que toutes les données et les opérations sont encapsulées dans des objets. En outre, les classes des objets sont définies dans une hiérarchie d’héritage unique.
1.2
Un programme Java doit contenir une classe public définie dans un fichier appelé X.java, X correspondant au nom de la classe. Cette classe doit comprendre une méthode déclarée de la façon suivante : • public static void main(String[] args)
1.3
Les types primitifs sont les suivants : boolean, char, byte, short, int, long, float ou double.
1.4
Un littéral est une constante anonyme ; un symbole qui représente une valeur constante du type. Par exemple, 4, 3.14 et "France" sont des littéraux.
1.5
Les trois littéraux non numériques des deux types à virgule flottante sont NEGATIVE_INFINITY, POSITIVE_INFINITY et NaN.
1.6
Une référence d’objet est une variable dont la valeur est null ou correspond à l’adresse d’un objet.
1.7
Un objet est un bloc contigu de stockage mémoire typé par une classe et auquel vous accédez via une variable de référence pour cette classe. Il peut être composé de plusieurs classes qui contiennent des données et peut avoir des méthodes qui effectuent des opérations.
1.8
Une classe est une méthodologie de création d’objets. La définition d’une classe spécifie les champs et les méthodes de chacune de ses instances.
1.9
Une instance de classe est un objet du type de cette classe. Le processus de création d’une instance est qualifié d’instanciation de la classe.
1.10 Un champ est une variable membre d’une classe. Lorsque la classe est instanciée, les champs
obtenus pour l’objet contiennent les données de ce dernier. 1.11 Une méthode est une fonction membre d’une classe. Lorsque cette dernière est instanciée, les
méthodes de l’objet obtenu effectuent certaines opérations pour ce dernier.
18
Caractéristiques de base du langage java
1.12 La signature d’une méthode est la partie de sa définition nécessaire à la compilation des instructions qui l’appellent. Par exemple, la signature de la méthode main() est la suivante : • main(String[])
1.13 Un constructeur est une méthode qui instancie sa classe. Il porte le même nom que la classe ellemême et n’a aucun type de renvoi. Il est appelé par l’opérateur new. 1.14 Un membre static s’applique à toute la classe et non à une instance. Il est appelé à l’aide du nom de la classe au lieu de celui de l’instance. Par exemple, la méthode sqrt(double) de la classe Math est statique. Elle est appelée sous la forme Math.sqrt(). Un champ static n’a
qu’une valeur de donnée quel que soit le nombre d’objets existant dans la classe, même s’il n’y en a aucun. 1.15 Un modificateur d’accès est l’un des trois mots-clés Java public, protected ou private qui
permettent de modifier une classe, un champ, une méthode ou une interface lorsque ces éléments sont définis. 1.16 Le modificateur d’accès private signifie que l’entité définie sera accessible uniquement à par-
tir de la classe dans laquelle elle est définie. 1.17 Le modificateur d’accès protected signifie que l’entité définie sera accessible uniquement
depuis la classe dans laquelle elle est définie ou depuis les sous-classes qui en découlent. 1.18 Une classe enveloppe a pour but de fournir des constantes et des méthodes destinées au traitement de l’un des huit types primitifs. Par exemple, la classe Double est une classe enveloppe du type primitif double. 1.19 La classe String se distingue des autres classes parce que ses instances sont immuables (en lecture seule), que ses littéraux sont uniques et qu’elle a deux opérateurs + et += destinés à la
concaténation. 1.20 La méthode Math.random() renvoie des nombres aléatoires à virgule flottante de type double
qui sont distribués uniformément dans un intervalle de 0.0 à 1.0.
?
EXERCICES D’ENTRAÎNEMENT
EXERCICES D’ENTRAÎNEMENT
1.1
Écrivez et testez la méthode suivante : • public static String monthName(int month) • // condition préalable : 0 < n et n < 13 • // exemple : monthName(3) renvoie "Mars"
1.2
Écrivez et testez la méthode suivante : • public static int daysInMonth(int month, int year) • // condition préalable : 0 < n et n < 13 • // exemple : daysInMonth(2,2000) renvoie 29
1.3
Écrivez et testez la méthode suivante : • public static int numberOfDigits(int n) • // exemple : numDigits(-8036800) renvoie 7
1.4
Écrivez et testez la méthode suivante : • public static int sumOfDigits(int n) • // exemple : sumOfDigits(-8036800) renvoie 25
Révision et entraînement
1.5
19
Écrivez et testez la méthode suivante : • public static int reverseDigits(int n) • // exemple : reverseDigits(-8036800) renvoie 572038
1.6
Écrivez et testez la méthode suivante : • public static double round(double x, int precision) • // exemple : round(803.505692,4) renvoie 803.1057
1.7
Écrivez et testez la méthode suivante : • public static String signedToBinary(int n) • // examples : signedToBinary( 1289) renvoie "010100001001" • // signedToBinary(-1289) renvoie "101011110111"
1.8
Écrivez et testez la méthode suivante : • public static String unsignedToBinary(int n) • // condition préalable : n >= 0 • // exemple : unsignedToBinary(1289) renvoie "10100001001"
1.9
Écrivez et testez la méthode suivante : • public static int binaryToSigned(String code) • // conditions préalables : chaque caractère du code est ’0’ ou ’1’; • code.length <= 32 • // exemple : binaryToSigned("010100001001") renvoie 1289 • // binaryToSigned("101011110111") renvoie -1289
1.10 Écrivez et testez la méthode suivante : • public static int binaryToUnsigned(String code) • // conditions préalables : chaque caractère du code est ’0’ ou ’1’; • code.length <= 32 • // exemple : binaryToUnsigned("010100001001") renvoie 1289 • // binaryToUnsigned("101011110111") renvoie 2807
1.11 Écrivez et testez la méthode suivante : • public static String format(String s, int len, int d) • // exemples : format("tomate",9,d) pour d = -1,0, 1 renvoie • // respectivement : • // "tomate " , " tomate " , " tomate"
1.12 Écrivez et testez la méthode suivante : • public static int randomInt(int start, int stop) • // conditions préalables : début < arrêt; • // renvoie des entiers distribués uniformément • // dans l’intervalle début à fin -1 (inclus)
1.13 Implémentez ce constructeur par défaut pour la classe Point (reportez-vous à l’exemple 1.7) : • public Point() • // construit un point représentant l’origine (0,0)
1.14 Ajoutez un objet public static final à la classe Point afin de représenter l’origine (0,0). 1.15 Implémentez le constructeur de copie suivant pour la classe Point (reportez-vous à l’exem-
ple 1.7) : • public Point(Point point) • // construit un point ayant les mêmes coordonnées que • // le point donné
20
Caractéristiques de base du langage java
1.16 Implémentez la méthode suivante pour la classe Point (reportez-vous à l’exemple 1.7) : • public double distance(Point point) • // renvoie la distance euclidienne de ce point au point donné
1.17 Implémentez la méthode suivante pour la classe Point (reportez-vous à l’exemple 1.7) : • public double magnitude() • // renvoie la distance euclidienne de ce point à l’origine
1.18 Implémentez la méthode suivante pour la classe Point (reportez-vous à l’exemple 1.7) : • public double amplitude() • // renvoie la mesure en radians de l’angle polaire du point
1.19 Implémentez le constructeur suivant pour la classe Point (reportez-vous à l’exemple 1.7) : • public void setPolar(double r, double theta) • // déplace ce point vers les coordonnées polaires données (r,theta) 1.20 Implémentez la méthode suivante pour la classe Point (reportez-vous à l’exemple 1.7) : • public static Point polar(double r, double theta) • // renvoie le point dont les coordonnées polaires sont (r,theta)
1.21 Implémentez la méthode suivante pour la classe Point (reportez-vous à l’exemple 1.7) : • public void expand(double dr) • // développe ce point par le facteur dr
1.22 Implémentez la méthode suivante pour la classe Point (reportez-vous à l’exemple 1.7) : • public void rotate(double theta) • // fait pivoter le point dans le sens des aiguilles d’une montre • // par theta radians
¿
SOLUTIONS
SOLUTIONS
1.1
• public static String monthName(int month) • { switch (month) • { case 1: return "Janvier"; • case 2: return "Février"; • case 3: return "Mars"; • case 4: return "Avril"; • case 5: return "Mai"; • case 6: return "Juin"; • case 7: return "Juillet"; • case 8: return "Août"; • case 9: return "Septembre"; • case 10: return "Octobre"; • case 11: return "Novembre"; • case 12: return "Décembre"; • } • return ""; •}
1.2
• public static int daysInMonth(int month, int year) • { if (month==4 || month==6 || month==9 || month==11) return 30; • if (month==2)
Révision et entraînement • if (year%400==0 || year%100!=0 && year%4==0) return 29; • else return 28; • return 31; •}
1.3
• public static int numberOfDigits(int n) • { if (n<0) n = -n; • int count=0; • while (n>0) • { n /= 10; • ++count; • } • return count; •}
1.4
• public static int sumOfDigits(int n) • { if (n<0) n = -n; • int sum=0; • while (n>0) • { sum += n%10; • n /= 10; • } • return sum; •}
1.5
• public static int reverseDigits(int n) • { if (n==0) return 0; • int sign = (n<0?-1:1); • if (n<0) n = -n; • int reverse=0; • while (n>0) • { reverse = 10*reverse + n%10; • n /= 10; • } • return sign*reverse; •}
1.6
• public static double round(double x, int precision) • { double pow10 = Math.pow(10,precision); • return Math.round(x*pow10)/pow10; •}
1.7
• public static String signedToBinary(int n) • { if (n==0) return "0"; • if (n>0) return "0" + unsignedToBinary(n); // exercice 1.8 • int mod=1; • while(mod+2*n<0) • mod *= 2; • return unsignedToBinary(mod+n); •}
1.8
• public static String unsignedToBinary(int n) • { // Condition préalable : n > 0 • String code=""; • while (n > 0) • { code = "" + (n%2) + code; // ajouter le bit suivant • // à gauche du code • n /= 2; // supprimer le bit courant le moins significatif • } • return code ; •}
21
22 1.9
Caractéristiques de base du langage java • public static int binaryToSigned(String code) • { int len = code.length(); • int unsigned = binaryToUnsigned(code); // exercice 1.10 • if (code.charAt(0) == ’0’) return unsigned; • return unsigned - (int)Math.pow(2,len); •}
1.10 • public static int binaryToUnsigned(String code) • { int n = code.length(); • int answer = 0; • for (int i=0; i
0)? spaces : spaces/2); • int rightSpaces = spaces - leftSpaces; • for (int i=0; i
1.14 Voici un exemple de champ public static final pour la classe Point : •public static final Point ORIGIN = new Point();
1.15 Voici un exemple de constructeur de copie pour la classe Point : • public Point(Point q) • { this.x = q.x; • this.y = q.y; }
1.16 Voici un exemple de méthode de distance pour la classe Point : • public double distance(Point point) • { double dx = this.x - point.x; • double dy = this.y - point.y; • return Math.sqrt(dx*dx+dy*dy); •}
1.17 Voici un exemple de méthode de grandeur pour la classe Point : • public double magnitude() • { return distance(ORIGIN); •}
Révision et entraînement
1.18 Voici un exemple de méthode d’amplitude pour la classe Point : • public double amplitude() • { return Math.atan(y/x); •}
1.19 Voici un exemple de méthode de la classe Point pour les coordonnées polaires : • public void setPolar(double r, double theta) • { this.x = r*Math.cos(theta); • this.y = r*Math.sin(theta); •}
1.20 Voici un autre exemple de méthode de la classe Point pour les coordonnées polaires : • public static Point polar(double r, double theta) • { double x = r*Math.cos(theta); • double y = r*Math.sin(theta); • return new Point(x,y); •}
1.21 Voici un exemple de méthode de développement pour la classe Point : • public void expand(double dr) • { x *= dr; • y *= dr; •}
1.22 Voici un exemple de méthode de rotation pour la classe Point : • public void rotate(double theta) • { double xx = x; • double yy = y; • double sin = Math.sin(theta); • double cos = Math.cos(theta); • x = xx*cos - yy*sin; • y = xx*sin + yy*cos; •}
23
Chapitre 2
Caractéristiques de base des tableaux Un tableau est un objet composé d’une séquence d’éléments numérotés de même type. Ces éléments sont numérotés à partir de 0 et peuvent être référencés par leur numéro grâce à l’opérateur d’index []. Les tableaux sont beaucoup utilisés en raison de leur efficacité.
2.1 PROPRIÉTÉS DES TABLEAUX Dans le cadre du langage de programmation Java, les tableaux présentent les propriétés suivantes : 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18.
Les tableaux sont des objets. Ils sont créés dynamiquement (au moment de l’exécution). Ils peuvent être affectés à des variables de type Object. Toutes les méthodes de la classe Object peuvent être appelées sur un tableau. Un objet tableau contient une séquence de variables qui sont toutes du même type. Les variables sont qualifiées de composants du tableau. Si le type de composant est T, le tableau a également le type T[]. Une variable de type tableau contient une référence à l’objet tableau. Le type de composant peut également avoir le type tableau. Un élément de tableau est un composant dont le type n’est pas un tableau. Un type d’élément peut être primitif ou de référence. La longueur d’un tableau correspond à son nombre de composants. La longueur d’un tableau est paramétrée lors de sa création et ne peut pas être modifiée par la suite. Pour être accessible, la longueur d’un tableau doit être définie comme une variable d’instance public final. Les tableaux doivent être indexés par des valeurs intégrales dans un intervalle de 0..length –1. Une exception ArrayIndexOutOfBoundsException est lancée si la propriété 15 n’est pas respectée. Les variables de type short, byte ou char peuvent être utilisées comme index. Les tableaux peuvent être copiés à l’aide de la méthode Object.clone().
26
Caractéristiques de base des tableaux
19. Il est possible de tester l’égalité des tableaux à l’aide de la méthode Arrays.equals(). 20. Les objets tableau implémentent Cloneable et java.io.Serializable. La propriété 3 découle de la propriété 1. Bien que le type tableau ne soit pas une classe, il se comporte comme une extension de la classe Object. La propriété 7 démontre que le type tableau est différent du type classe (reportez-vous à la première figure du chapitre 1). En fait, il s’agit d’un type dérivé : pour chaque type de classe T, il existe un type de tableau correspondant T[]. En outre, pour chacun des huit types primitifs, il existe un type de tableau correspondant. La propriété 9 permet la création de tableaux de tableaux. Techniquement parlant, Java autorise les tableaux multidimensionnels uniquement pour les types primitifs. Cependant, dans le cas des objets, il n’y a pas énormément de différence entre des objets et un tableau de tableaux. En effet, les tableaux étant eux-mêmes des objets, un tableau de tableaux est, par définition, un tableau d’objets. En outre, certains objets composants peuvent également être différents d’un tableau (reportez-vous à l’exemple 2.1). En raison de la propriété 13, l’affectation de null à une valeur de composant de référence n’affecte en rien la longueur du tableau ; null reste une valeur valide pour le composant de référence.
Exemple 2.1 Quelques définitions de tableaux Vous trouverez ci-après des exemples de définitions de tableaux : public class Ex0201 { public static void main(String[] args) { float x[]; x = new float[100]; args = new String[10]; boolean[] isPrime = new boolean[1000]; int fib[] = { 0, 1, 1, 2, 3, 5, 8, 13 }; short[][][] b = new short[3][8][5]; double a[][] = { {1.1,2.2}, {3.3,4.4}, null, {5.5,6.6}, null }; a[4] = new double[66]; a[4][65] = 3.14; Object[] objects = { x, args, isPrime, fib, b, a }; } }
La première ligne déclare x[] comme tableau de floats mais n’alloue aucun de ces derniers. La deuxième ligne définit x[] comme ayant 100 composants de type float. La troisième ligne déclare args[] comme tableau d’objets String. Remarquez les deux méthodes (équivalentes) de déclaration d’un tableau : les crochets peuvent être le suffixe de l’identificateur de type ou bien de celui du tableau. La quatrième ligne définit args[] avec 10 composants String. La cinquième ligne définit isPrime[] comme tableau de 1 000 variables boolean. La sixième ligne définit fib[] comme tableau de 8 int initialisés aux 8 valeurs listées. Ainsi, fib[4] a la valeur 3 et fib[7] a la valeur 13. La huitième ligne définit a[][] comme tableau de cinq composants, chacun d’entre eux étant un tableau d’éléments de type double. Seuls trois des cinq tableaux composants sont alloués. La ligne suivante alloue un tableau de 66 éléments de type double à a[4] et la dernière ligne affecte 3.14 à son dernier élément. La dernière ligne définit le tableau objects avec six composants, chacun d’entre eux étant un tableau. Les composants des quatre premiers tableaux composants sont des éléments, c’est-à-dire qu’ils ne sont pas des tableaux. Mais les composants b et a ne sont pas des éléments parce qu’ils sont également des tableaux. Les éléments du tableau objects comprennent 2, 5 et 13 (composants du composant fib), null (composant du composant a), ainsi que 2.2 et 3.14 (composants des composants du composant a).
Copier un tableau
27
Le tableau a[][] défini dans l’exemple 2.1 est qualifié de tableau extensif parce qu’il s’agit d’un tableau bidimensionnel composé de lignes de différentes longueurs. Dans le cadre de Java, l’élément d’un tableau peut être de type primitif, ou bien de type tableau ou référence. Les tableaux les plus simples sont bien évidemment ceux qui sont composés d’éléments de type primitif, par exemple x[], isPrime[] et fib[] dans l’exemple 2.1. Ces tableaux présentent l’avantage de pouvoir être triés.
2.2 COPIER UN TABLEAU Étant donné qu’un tableau est un objet, il peut être copié en appelant la méthode Object.clone(), comme illustré dans l’exemple suivant.
Exemple 2.2 Copier un tableau public class Ex0202 { public static void main(String[] args) { int[] a = { 22, 44, 66, 88 }; print(a); int[] b = (int[])a.clone(); // copier a[] dans b[] print(b); String[] c = { "AB", "CD", "EF" }; print(c); String[] d = (String[])c.clone(); // copier c[] dans d[] print(d); c[1] = "XYZ"; // modifier c[], mais pas d[] print(c); print(d); } public static void print(int[] a) { for (int i=0; i
44 66 88 44 66 88 CD EF CD EF XYZ EF CD EF
Le tableau a[] contient quatre éléments int. Le tableau b[] est une copie de a[]. De la même façon, le tableau d[] est une copie du tableau c[], chacun d’entre eux contenant trois éléments String. Dans les deux cas, la copie est obtenue en appelant la méthode clone(). Étant donné que cette méthode renvoie une référence à un Object, le transtypage doit être effectué vers le type du tableau copié, c’est-à-dire int[] ou String[].
28
Caractéristiques de base des tableaux
La dernière partie de l’exemple illustre le fait que le tableau cloné d[] soit une copie séparée de c[] : la modification de c[1] en "XYZ" n’affecte en aucun cas la valeur "CD" de d[1].
2.3 CLASSE Arrays La classe java.util.Arrays définit les méthodes suivantes : public public public public public
static static static static static
List asList(Object[]) int binarySearch(...) boolean equals(...) void fill(...) void sort(...)
Dans le cas présent, les points de suspension entre parenthèses indiquent que la méthode est surchargée pour différents types de paramètre, à la fois primitifs et de référence. Par exemple, il existe neuf versions de la méthode binarySearch(…) : une pour le tableau de chaque type primitif à l’exception du type boolean, et deux pour les tableaux de type Object[]. Notez que toutes les méthodes de la classe Arrays sont static et sont donc appelées à l’aide du préfixe Arrays au lieu du nom de l’instance de classe. En fait, il n’est pas possible d’instancier la classe Arrays parce que son constructeur est déclaré comme private.
Exemple 2.3 Tester les méthodes de la classe Arrays import java.util.Arrays; public class Ex0203 { public static void main(String[] args) { char[] a = new char[64]; Arrays.fill(a,’H’); String s = new String(a); System.out.println("s = \"" + s + "\""); Object[] objects = new Object[8]; Arrays.fill(objects,2,5,"Java"); System.out.println("objects = " + Arrays.asList(objects)); int[] x = { 77, 44, 99, 88, 22, 33, 66, 55 }; int[] y = (int[])x.clone(); System.out.print("x = "); print(x); System.out.print("y = "); print(y); System.out.println("Arrays.equals(x,y) = " + Arrays.equals(x,y)); System.out.println("y.equals(x) = " + y.equals(x)); y[4] = 0; System.out.print("y = "); print(y); System.out.println("Arrays.equals(x,y) = " + Arrays.equals(x,y)); System.out.print("x = "); print(x); Arrays.sort(x); System.out.print("x = "); print(x); int i = Arrays.binarySearch(x,44); System.out.println("Arrays.binarySearch(x,44) = " + i); i = Arrays.binarySearch(x,47); System.out.println("Arrays.binarySearch(x,47) = " + i); } private static void print(int[] a) { System.out.print("{ " + a[0]); for (int i=1; i
Classe Arrays
29
s = "HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH" objects = [null, null, Java, Java, Java, null, null, null] x = { 77, 44, 99, 88, 22, 33, 66, 55 } y = { 77, 44, 99, 88, 22, 33, 66, 55 } Arrays.equals(x,y) = true y.equals(x) = false y = { 77, 44, 99, 88, 0, 33, 66, 55 } Arrays.equals(x,y) = false x = { 77, 44, 99, 88, 22, 33, 66, 55 } x = { 22, 33, 44, 55, 66, 77, 88, 99 } Arrays.binarySearch(x,44) = 2 Arrays.binarySearch(x,47) = -4
Les trois premières lignes construisent un objet String avec plusieurs instances d’un même caractère. Nous définissons d’abord a comme tableau composé de 64 char. Nous utilisons ensuite la méthode Arrays.fill() pour le remplir à l’aide du caractère voulu, ’H’ dans le cas présent. Nous utilisons ensuite le constructeur String approprié de façon à créer un objet String avec le même contenu. Puis, nous construisons un tableau appelé Object et composé de huit références. Nous entrons les éléments indexés de 2 à 4 avec l’objet "Java" de type String. Remarquez que les paramètres entiers 2 et 5 sont utilisés pour indiquer le sous-intervalle de valeurs à remplir. Le premier entier, 2, est l’index de départ, et le second est l’index du premier élément suivant qui ne sera pas modifié. Ce protocole de définition des sous-intervalles est souvent utilisé dans les bibliothèques standard. C’est pourquoi le nombre d’éléments du sous-intervalle est toujours égal à la différence entre les deux paramètres, dans le cas présent 5 – 2 = 3 éléments ont été modifiés. Il n’existe pas de méthode toString() pour les tableaux. Contrairement à d’autres objets, ils peuvent donc être imprimés directement. Cependant, la méthode Arrays.toList() crée un objet List qui peut être passé à la méthode System.out.println() parce qu’il a une méthode toString(). Il s’agit là d’un procédé simple permettant d’imprimer un tableau d’objets. La partie suivante de l’exemple crée deux tableaux int, x et y, en utilisant la méthode Object .clone() pour copier x dans y (reportez-vous à la section 2.2). Les méthodes Arrays.equals() et Object.equals() sont ensuite appelées afin de vérifier l’égalité. Remarquez que seule la première de ces méthodes renvoie la bonne réponse. Nous modifions ensuite y[4] de façon à vérifier si la méthode Arrays.equals() fonctionne correctement lorsque les deux tableaux ne sont pas égaux. La méthode Arrays.sort() permet de trier x. Nous pouvons ensuite utiliser la méthode Arrays .binarySearch() pour rechercher un int donné dans x. Si cet élément se trouve dans le tableau, la méthode renvoie son index, c’est-à-dire 2 dans notre exemple. Dans le cas contraire, la méthode renvoie un entier négatif afin de signaler que l’élément ne se trouve pas dans le tableau. L’algorithme de recherche binaire générique est défini dans la section 2.5. Remarquez que la méthode Arrays.binarySearch() ne fonctionnera pas correctement si le tableau n’a pas été trié auparavant. La méthode Arrays.equals() est destinée à être utilisée à la place de la méthode Object .equals() pour les tableaux. Cette deuxième méthode renvoie true uniquement lorsque les deux références concernent le même objet, c’est-à-dire que l’identité est testée au lieu de l’égalité. Afin d’illustrer plus en détail les algorithmes de tableaux présentés dans ce livre, nous allons maintenant définir une autre classe Arrays. Pour éviter un conflit de nom, cette classe sera définie dans un paquetage séparé appelé schaums.dswj.
30
Caractéristiques de base des tableaux
Exemple 2.4 Classe utilitaire Arrays package schaums.dswj; import java.util.Random; public class Arrays { private static Random random = new Random(); public static int load(int start, int range) { return random.nextInt(range) + start; } public static void load(int[] a, int start, int range) { int n=a.length; for (int i=0; i9?"":" ") + i); System.out.print("\n{ " + a[0]); for (int i=1; i
Initialement, cette classe test n’a que trois méthodes : deux méthodes load() permettant d’initialiser les variables et les tableaux à l’aide d’entiers aléatoires et une méthode print() permettant d’imprimer des tableaux d’entiers. Les méthodes load() limitent les valeurs entières du début de l’intervalle à load –1. Cela facilite la création des valeurs copiées. La méthode print() annote la liste du tableau à l’aide d’une ligne des numéros d’index afin de faciliter la recherche de chaque élément indexé. Le pilote test suivant illustre le fonctionnement de cette classe : import schaums.dswj.Arrays; public class Testing { private static final private static final private static final private static int[]
int int int a =
SIZE = 16; START = 40; RANGE = 20; new int[SIZE];
public static void main(String[] args) { Arrays.load(a,START,RANGE); Arrays.print(a); Arrays.load(a,START,RANGE); Arrays.print(a); } } 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 { 49, 56, 46, 43, 40, 57, 47, 43, 43, 43, 46, 57, 47, 53, 44, 46 } 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 { 58, 55, 40, 45, 56, 46, 59, 59, 57, 45, 46, 42, 52, 47, 42, 54 }
31
Algorithme de recherche séquentielle
Ce programme génère deux tableaux aléatoires composés de 16 éléments chacun. Ces éléments se trouvent dans l’intervalle 40 à 59 et sont donc susceptibles d’avoir des copies. Par exemple, dans le premier tableau, a[2] = a[10] = 46.
2.4 ALGORITHME DE RECHERCHE SÉQUENTIELLE La recherche séquentielle (également appelée recherche linéaire) est l’algorithme de recherche le plus simple, mais également le moins efficace. Cet algorithme étudie simplement chaque élément de façon séquentielle. Il commence donc par le premier élément et continue jusqu’à ce qu’il trouve l’élément clé ou qu’il atteigne la fin du tableau. Par exemple, si vous cherchez quelqu’un dans un train en marche, vous utilisez une recherche séquentielle, comme illustré dans la figure suivante : ? 0
? 1
? 3
? 4
5
6
7
8
9
Algorithme 2.1 Recherche séquentielle (Condition préalable : s = {s0, s1, s2, . . ., sn – 1} est une séquence de n valeurs ordinales du même type que x.) (Condition postérieure : l’index i est renvoyé quand si = x, ou –1 est renvoyé.) 1. 2. 3. 4.
Effectuez les étapes 2 et 3 n fois pour i = 0 jusqu’à n – 1. (Invariant : aucun des éléments de la séquence suivante {s0..si – 1} n’est égal à x.) Si si = x, renvoyer i. Renvoyer –1.
Dans l’algorithme 2.1 (et dans tous les algorithmes de ce livre), nous préciserons les conditions préalables et postérieures afin d’indiquer très exactement ce que fait l’algorithme. En outre, nous utiliserons des invariants de boucle afin de démontrer l’exactitude de l’algorithme. Nous proposerons également un exemple Java de mise en pratique de chaque algorithme.
Exemple 2.5 Recherche séquentielle public static int sequentialSearch(int[] a, int x) { // Conditions postérieures : renvoie i; si i >= 0, alors a[i] == x; // sinon i == -1; for (int i=0; i
✽ Théorème 2.1 : la recherche séquentielle est correcte. Démonstration : si n = 0, la séquence est vide et la boucle n’est pas du tout exécutée. Seule l’étape 4 est exécutée et elle renvoie –1 immédiatement. Cela respecte les conditions postérieures puisque x ne peut pas être égal à l’un des éléments parce qu’il n’y en a aucun. Si n = 1, la boucle n’est itérée qu’une seule fois, avec i = 0. Lors de cette itération, s0 = x ou s0 ≠ x. Si s0 = x, 0 est renvoyé et la condition postérieure est respectée. Si s0 ≠ x, la boucle s’arrête, l’étape 4 est exécutée et –1 est renvoyé, ce qui respecte la condition postérieure puisque le seul élément de la séquence n’est pas égal à x.
32
Caractéristiques de base des tableaux
Supposons que n > 1. Lors de la première itération de la boucle, i = 0 et l’invariant de boucle de l’étape 2 est vide et donc true parce que la sous-séquence {s0..si – 1} est vide. Ensuite, au cours de l’étape 3, s0 = x ou s0 ≠ x. Si s0 = x, 0 est renvoyé et la condition postérieure est respectée. Si s0 ≠ x, la boucle continue. S’il y a une deuxième itération (c’est-à-dire, si s0 ≠ x), i = 1 et l’invariant de boucle de l’étape 2 est encore true parce que la sous-séquence {s0..si – 1} = {s0} et que s0 ≠ x. Supposons que, lors de la kième itération de la boucle, l’invariant de cette dernière soit true, c’està-dire qu’aucun des éléments de la sous-séquence {s0..sk – 1} soit égal à x. Au cours de cette itération, à l’étape 3, si = x ou si ≠ x. Si si = x, k est renvoyé et la condition postérieure est respectée. Si si ≠ x, la boucle continue. D’après le principe d’induction mathématique (reportez-vous à la section A.4), après chaque itération de boucle, l’algorithme se termine par une condition postérieure true ou bien c’est l’invariant de boucle de l’itération suivante qui sera true. Ainsi, si l’algorithme ne se termine au cours d’aucune itération, l’invariant de boucle du cas i = n sera true après la dernière itération, lorsque i = n –1. En effet, aucun élément de la sous-séquence {s0..sn – 1} n’est égal à x. À ce stade, –1 est renvoyé et la condition postérieure est respectée. Le théorème suivant utilise la notation O(). Reportez-vous à la section A.3 pour revoir ces bases mathématiques. ✽ Théorème 2.2 : la recherche séquentielle est exécutée en une durée O(n). Démonstration : si x se trouve dans la séquence, disons à x = si avec i < n, la boucle est itérée i fois. Dans ce cas, la durée d’exécution est proportionnelle à i, soit O(n) puisque i < n. En revanche, si x ne se trouve pas dans la séquence, la boucle est itérée n fois, d’où une durée d’exécution proportionnelle à n, soit O(n).
Exemple 2.6 Tester la recherche séquentielle import schaums.dswj.Arrays; public class Testing { private static final private static final private static final private static int[]
int int int a =
SIZE = 16; START = 40; RANGE = 20; new int[SIZE];
public static void main(String[] args) { Arrays.load(a,START,RANGE); Arrays.print(a); test(); test(); test(); test(); } public static void test() { int x = Arrays.load(START,RANGE); System.out.print("Recherche de x = " + x + ":\t"); int i = Arrays.sequentialSearch(a,x); if (i >= 0) System.out.println("a[" + i + "] = " + a[i]); else System.out.println("i = " + i + " ==> x introuvable"); } }
33
Algorithme de recherche binaire
0 1 { 49, 44, Recherche Recherche Recherche Recherche
2 3 4 5 6 7 8 9 10 11 12 13 14 15 49, 41, 50, 59, 51, 48, 48, 41, 50, 47, 41, 58, 46, 48 } de x = 51: a[6] = 51 de x = 47: a[11] = 47 de x = 56: i = -1 ==> x introuvable de x = 50: a[4] = 50
Ce programme teste l’algorithme de recherche séquentielle quatre fois sur le tableau généré par load(). Le premier test recherche x = 51 et le trouve à a[6]. Le deuxième recherche x = 47 et le trouve à a[11]. Le troisième recherche x = 56 et échoue, c’est pourquoi il renvoie –1. Le quatrième recherche x = 50 et le trouve à a[4]. Remarquez que cette valeur se trouve également à a[10]. La recherche séquentielle s’arrête dès qu’elle trouve l’élément recherché et elle ignore le reste du tableau. Chaque algorithme de tableau est ajouté à la classe schaums.dswj.Arrays afin d’en faciliter l’accès. Ainsi, pour tester la recherche séquentielle, nous importons cette classe, puis nous appelons la méthode de recherche Arrays.sequentialSearch().
2.5 ALGORITHME DE RECHERCHE BINAIRE La recherche binaire est la procédure standard de recherche dans une séquence triée. Elle est beaucoup plus efficace que la recherche séquentielle, mais les éléments doivent être triés pour qu’elle soit utilisable. Elle divise à plusieurs reprises la séquence en deux, puis limite à chaque fois la recherche à la moitié contenant l’élément. Ce type de recherche est notamment utile lorsque vous souhaitez rechercher un mot dans le dictionnaire.
Algorithme 2.2 Recherche binaire
?
?
?
?
(Condition préalable : s = {s0, s1, s2, …, sn – 1} est une séquence triée de valeurs ordinales n du même type que x.) (Condition postérieure : l’index i est renvoyé si si = x ou bien –1 est renvoyé.) 1. Supposons que ss soit une sous-séquence de s, initialement paramétrée de façon à être égale à s. 2. Si la sous-séquence ss est vide, renvoyer –1. 3. (Invariant : si x se trouve dans la séquence initiale s, il doit se trouver dans la sous-séquence ss.) 4. Supposons que si soit l’élément central de ss. 5. Si si = x, renvoyer son index i. 6. Si si < x, répétez les étapes 2 à 7 sur la sous-séquence située au-dessus de si. 7. Répétez les étapes 2 à 7 sur la sous-séquence située sous si. Notez que la condition préalable de l’algorithme 2.2 ne peut être appliquée qu’à une séquence triée. La recherche binaire est implémentée dans la classe java.util.Arrays (reportez-vous à la section 2.3). Vous en trouverez ci-après une version annotée :
Exemple 2.7 Recherche binaire public static int binarySearch(int[] a, int x) { // Condition préalable : a[0] <= a[1] <= ... <= a[a.length-1]; // Conditions postérieures : renvoie i; si i >= 0, alors a[i] == x; // sinon i == -1;
34
Caractéristiques de base des tableaux
int lo=0, hi=a.length-1; while (lo <= hi) // étape 1 { // INVARIANT : si a[j]==x alors lo <= j <= hi; // étape 3 int i = (hi + lo)/2; // étape 4 if (a[i] == x) return i; // étape 5 else if (a[i] < x) lo = i+1; // étape 6 else hi = i-1; // étape 7 } return -1; // étape 2 }
✽ Théorème 2.3 : la recherche binaire est correcte. Démonstration : l’invariant de boucle est true à la première itération parce que la sous-séquence courante est identique à la séquence initiale. À chaque autre itération, la sous-séquence courante a été définie dans l’itération précédente comme la moitié de la sous-séquence précédente qui restait après l’omission de la moitié qui ne contenait pas x. Ainsi, si x se trouvait dans la séquence initiale, il doit se trouver dans la sous-séquence courante. L’invariant de boucle est par conséquent true à chaque itération. Pour chaque itération, i est renvoyé lorsque si = x ou bien la sous-séquence est réduite de plus de 50 %. Étant donné que la séquence initiale ne contient qu’un nombre fini d’éléments, la boucle ne peut pas continuer indéfiniment. C’est pourquoi l’algorithme s’arrête soit en renvoyant i depuis la boucle, soit à l’étape 6 ou 7 lorsque –1 est renvoyé. Si i est renvoyé depuis la boucle, si = x. Si tel n’est pas le cas, la boucle se termine lorsque grand (hi) < petit (lo), c’est-à-dire lorsque la sous-séquence est vide. Dans ce cas, nous savons par l’invariant de boucle que si ne se trouve pas dans la séquence initiale. ✽ Théorème 2.4 : la recherche binaire est exécutée en une durée O(lgn). Démonstration : dans la démonstration du théorème 2.3, nous avons vu que le nombre d’itérations est au maximum égal au nombre de fois (plus 1) où n peut être divisé par deux. Ce nombre correspond au logarithme binaire intégral lgn (reportez-vous à l’annexe A pour plus d’informations).
Exemple 2.8 Tester la recherche binaire import schaums.dswj.Arrays; public class Ex0208 { private static final private static final private static final private static int[]
int int int a =
SIZE = 16; START = 40; RANGE = 20; new int[SIZE];
public static void main(String[] args) { Arrays.load(a,START,RANGE); Arrays.print(a); test(); java.util.Arrays.sort(a); Arrays.print(a); test(); test(); test(); } public static void test() { int x = Arrays.load(START,RANGE); System.out.print("Recherche de x = " + x + ":\t"); int i = Arrays.binarySearch(a,x); if (i >= 0) System.out.println("a[" + i + "] = " + a[i]); else System.out.println("i = " + i + " ==> x introuvable"); } }
35
Classe Vector
0 1 { 48, 57, Recherche 0 1 { 42, 45, Recherche Recherche Recherche
2 3 4 5 6 7 46, 51, 55, 51, 55, 45, de x = 50: i = -1 ==> x 2 3 4 5 6 7 45, 46, 47, 47, 48, 50, de x = 50: a[7] = 50 de x = 47: a[5] = 47 de x = 58: i = -1 ==> x
8 9 10 47, 52, 57, introuvable 8 9 10 51, 51, 52,
11 12 13 14 15 47, 50, 42, 59, 45 } 11 12 13 14 15 55, 55, 57, 57, 59 }
introuvable
Ce programme teste l’algorithme de recherche binaire quatre fois sur le tableau généré par load(). Le premier test recherche x = 50 et échoue bien que a[7] = 50 parce que le tableau n’est pas encore trié. Une fois que java.util.Arrays.sort(a) a trié le tableau, le deuxième test trouve x = 50 à a[7]. Le troisième test recherche x = 57 et le trouve à a[5]. Remarquez qu’il ne s’agit pas de l’occurrence la plus à gauche de cette valeur qui apparaît aussi à a[4]. En fait, la recherche binaire n’est pas séquentielle, c’est pourquoi il n’est pas facile de savoir quel index sera renvoyé par l’algorithme lorsqu’une valeur apparaît plusieurs fois (reportez-vous à la question de révision 2.9). Le quatrième test recherche x = 58 et échoue, c’est pourquoi il renvoie –1.
2.6 CLASSE Vector Mathématiquement, un vecteur est simplement une séquence finie de nombres. Géométriquement, nous pensons généralement à un vecteur bidimensionnel (x, y) comme représentant un point dans un plan et à un vecteur tridimensionnel (x, y, z) comme représentant un point dans l’espace. Les vecteurs composés d’un nombre n fini d’éléments sont courants en algèbre linéaire : (x1, x2, …, xn) . Ce procédé requiert l’utilisation des index. Dans le cadre de Java, un vecteur est identique à un tableau, à l’exception des points suivants : • Un vecteur est une instance de la classe java.util.Vector. • Il est possible de modifier la longueur d’un vecteur. La classe Vector a été largement réécrite dans Java 1.2. Elle est définie de la façon suivante dans le paquetage java.util : public class Vector extends AbstractList implements List { public boolean add(Object object) public void add(int index, Object object) public boolean addAll(Collection collection) public boolean addAll(int index, Collection collection) public void addElement(Object object) public void clear() public Object clone() public boolean contains(Object object) public boolean containsAll(Collection collection) public void copyInto(Object[] objects) public Object elementAt(int index) public boolean equals(Object object) public Object firstElement() public Object get(int index) public int hashCode() public int indexOf(Object object) public int indexOf(Object object, int index) public void insertElementAt(Object object, int index)
36
Caractéristiques de base des tableaux
public public public public public public public public public public public public public public public public public public public public
boolean isEmpty() Object lastElement() int lastIndexOf(Object object) int lastIndexOf(Object object, int index) Object remove(int index) boolean remove(Object object) boolean removeAll(Collection collection) void removeAllElements() boolean removeElement(Object object) void removeElementAt(int index) boolean retainAll(Collection collection) Object set(int index, Object object) void setElementAt(Object object, int index) int size() List subList(int start, int stop) Object[] toArray() Object[] toArray(Object[] objects) String toString() Vector() Vector(Collection collection)
}
Les méthodes add permettent d’insérer de nouveaux éléments dans le vecteur. Les méthodes add(object) et addElement(object) ont le même effet, mais la première renvoie true (ou false en cas d’échec). Si l’emplacement du ou des nouveaux éléments n’est pas spécifié, la fin du vecteur est utilisée par défaut. La méthode clear() réduit le vecteur de façon à ce que sa taille soit égale à zéro, c’est-à-dire qu’il soit vide. Remarquez qu’un vecteur vide est différent d’une référence null puisque l’objet vecteur existe encore. La méthode clone() copie tout le vecteur, et donc l’objet qu’il contient. La méthode contains détermine si les objets donnés sont des éléments du vecteur. La méthode copyInto copie les éléments du vecteur dans le tableau donné. Les méthodes elementAt() et get() sont semblables à l’opérateur d’index pour les tableaux puisqu’elles renvoient l’élément vecteur à l’index donné. La méthode equals() teste l’égalité d’un autre objet et renvoie true si et uniquement si l’objet donné est un vecteur dont les éléments sont égaux au vecteur appelé. Les méthodes firstElement() et lastElement() renvoient simplement le premier et le dernier élément du vecteur. La méthode hashCode() renvoie un numéro d’identification pour l’objet vecteur. Les méthodes indexOf utilisent la recherche séquentielle pour retrouver et renvoyer l’index d’un objet donné du vecteur. Elles renvoient –1 si l’objet n’est pas trouvé. La version à deux paramètres commence sa recherche à l’index donné. La méthode insertElementAt() insère l’objet donné dans le vecteur à l’index donné. Tous les éléments existants sont alors déplacés vers l’avant à partir de cet index. Les méthodes lastIndexOf fonctionnent comme indexOf(), mais elles exécutent la recherche séquentielle à l’envers. Les méthodes remove suppriment du vecteur un segment composé d’un ou de plusieurs éléments. Les éléments existants qui se trouvaient au-delà du segment supprimé sont alors déplacés vers l’arrière, ce qui provoque un résultat inverse à celui de la méthode insertElementAt(). Remarquez le point suivant : bien qu’il existe une seule méthode insert, six méthodes remove (public) sont à votre disposition. Les méthodes remove(index) et removeElementAt(index) ont les mêmes conséquences, mais la première renvoie l’objet supprimé (ou null en cas d’échec), tandis que la dernière renvoie true (ou false en cas d’échec).
Classe Vector
37
Les méthodes set(index,object) et setElementAt(object,index) remplacent toutes les deux l’élément à l’index donné par l’objet donné. Elles ont le même effet, sauf que la première renvoie l’objet supprimé (ou null en cas d’échec). La méthode subList() renvoie un objet List contenant les objets du vecteur de l’index start à l’index stop -1. C’est pourquoi la taille de l’objet List obtenu est stop – start. Les méthodes toArray() renvoient un tableau Object[] qui contient les mêmes éléments que le vecteur. La version sans paramètres crée le tableau renvoyé et a donc la même taille que le vecteur. La version avec le paramètre Object[] effectue la même opération si la taille du tableau donné est inférieure à la taille du vecteur. Si tel n’est pas le cas, elle copie les éléments du vecteur au début du tableau donné, puis elle attribue la valeur null aux composants restants. La méthode toString() renvoie une chaîne qui représente le contenu du vecteur.
Exemple 2.9 Tester la classe java.util.Vector import java.util.*; public class Ex0209 { private static Vector v = new Vector(); private static Vector w = new Vector(); public static void main(String[] args) { String[] villes = { "Austin", "Boston", "Milan", "Moscou" }; v.addAll(Arrays.asList(villes)); System.out.println("v = " + v); v.add("Paris"); System.out.println("v = " + v); w = (Vector)v.clone(); System.out.println("w = " + w); System.out.println("w.equals(v) = " + w.equals(v)); v.set(3,"Ottawa"); System.out.println("v = " + v); System.out.println("w = " + w); System.out.println("w.equals(v) = " + w.equals(v)); v.insertElementAt("Londres",3); System.out.println("v = " + v); System.out.println("w = " + w); System.out.println("w.equals(v) = " + w.equals(v)); w.removeElementAt(1); w.removeElementAt(3); w.remove("Milan"); System.out.println("w = " + w); v.addAll(5,w); System.out.println("v = " + v); System.out.println("v.indexOf(\"Austin\") = " + v.indexOf("Austin")); System.out.println("v.indexOf(\"Austin\",2) = " + v.indexOf("Austin",2)); System.out.println("v.indexOf(\"Dublin\") = " + v.indexOf("Dublin")); } }
38
Caractéristiques de base des tableaux
v = [Austin, Boston, Milan, v = [Austin, Boston, Milan, w = [Austin, Boston, Milan, w.equals(v) = true v = [Austin, Boston, Milan, w = [Austin, Boston, Milan, w.equals(v) = false v = [Austin, Boston, Milan, w = [Austin, Boston, Milan, w.equals(v) = false w = [Austin, Moscou] v = [Austin, Boston, Milan, v.indexOf("Austin") = 0 v.indexOf("Austin",3) = 5 v.indexOf("Dublin") = -1
Moscou] Moscou, Paris] Moscou, Paris] Ottawa, Paris] Moscou, Paris] Londres, Ottawa, Paris] Moscou, Paris] Londres, Ottawa, Austin, Moscou, Paris]
Le tableau villes permet de créer le vecteur v en passant l’objet List créé par la méthode Arrays.asList() au constructeur Vector qui prend l’objet Collection comme paramètre (une List est une Collection). La méthode System.out.println() appelle la méthode toString() du vecteur pour l’imprimer. L’appel v.add("Paris") ajoute la nouvelle chaîne à la fin du vecteur et augmente ainsi sa taille. L’appel v.clone() renvoie une copie du vecteur v, mais comme type Object. C’est pourquoi il doit être transtypé en Vector afin d’être affecté à la référence w. La méthode equals() montre que v et w sont égaux. L’appel v.set(3,"Ottawa") modifie v, mais pas w et vérifie si les deux vecteurs sont différents, mais égaux. Après avoir supprimé les trois éléments de w, l’appel v.addAll(5,w) insère des copies de tous les éléments de w dans v en commençant à la cinquième position (c’est-à-dire juste après les cinq premiers éléments). En dernier lieu, la méthode indexOf() permet de rechercher les éléments de v.
?
QUESTIONS DE RÉVISION
QUESTIONS DE RÉVISION
2.1
Quelle est la différence entre un composant et un élément de tableau ?
2.2
Que signifie exactement le fait que Java n’autorise pas les tableaux multidimensionnels ?
2.3
Qu’est-ce qu’une exception ArrayIndexOutOfBoundsException et en quoi son utilisation différencie-t-elle Java d’autres langages de programmation tels que le C et le C++ ?
2.4
Quels sont les types valides pour les index de tableaux ?
2.5
En quoi cette définition est-elle erronée ? •Arrays arrays = new Arrays();
2.6
Quelle est la méthode d’impression d’un tableau d’objets la plus simple ?
2.7
Si la recherche binaire est nettement plus rapide que la recherche séquentielle, quel est l’intérêt d’utiliser cette dernière ?
2.8
Que se passe-t-il si la recherche séquentielle est appliquée à un élément qui apparaît plusieurs fois dans le tableau ?
2.9
Que se passe-t-il si la recherche binaire est appliquée à un élément qui apparaît plusieurs fois dans le tableau ?
Révision et entraînement
39
2.10 Quelle est la différence entre l’appel de la méthode clear() sur un objet Vector et l’affectation de la valeur null à ce dernier ?
¿
RÉPONSES
RÉPONSES
2.1
Un composant de tableau peut être de type primitif, ou bien de type référence ou tableau. Un élément de tableau est un composant qui n’est pas un type de tableau. C’est pourquoi, dans le langage Java, les composants de a[] sont les lignes des tableaux et les éléments de a[][] sont des variables de type double.
2.2
Un tableau multidimensionnel comporte plusieurs index. Un tableau Java n’a qu’une seule variable d’index. Cependant, étant donné qu’un composant indexé par la variable peut être un tableau (avec un index), le tableau initial semble avoir plusieurs index.
2.3
Un objet ArrayIndexOutOfBoundsException est une exception qui est lancée dès que vous essayez d’utiliser une valeur inférieure à zéro ou bien supérieure ou égale à la longueur du tableau comme index sur le tableau. Grâce à ce procédé, le programmeur contrôle mieux les conséquences d’une telle erreur d’exécution. Dans des langages tels que le C++, ce type d’erreur provoque généralement le plantage du programme.
2.4
Un index de tableau peut être de type byte, char, short ou int.
2.5
La classe Array ne peut pas être instanciée parce que son constructeur est déclaré comme private.
2.6
La méthode la plus simple pour imprimer un tableau d’objets consiste à le passer à la méthode Arrays.toList() qui crée un objet List pouvant être imprimé directement à l’aide de la méthode System.out.println().
2.7
La recherche binaire ne peut pas fonctionner si le tableau n’a pas été trié au préalable.
2.8
Si la recherche séquentielle est appliquée à un élément qui apparaît plusieurs fois dans le tableau, elle renvoie l’index le plus proche du début du tableau.
2.9
Si la recherche binaire est appliquée à un élément qui apparaît plusieurs fois dans le tableau, elle est susceptible de renvoyer n’importe quel index ; cela dépend de l’emplacement des index par rapport aux multiples du point médian des sous-intervalles. Par exemple, si la recherche binaire est appliquée à un tableau de 10 000 éléments et que vous recherchez un élément répété aux emplacements 0-99, elle renverra l’index 77 à la 77e itération.
2.10 L’appel v.clear() fait de v un vecteur vide qui reste un objet non null. L’affectation v = null détruit l’objet. Dans le premier cas, l’expression v.size() serait évaluée à 0 ; dans le deuxième,
elle lancerait une exception.
?
EXERCICES D’ENTRAÎNEMENT
EXERCICES D’ENTRAÎNEMENT
2.1
Exécutez un programme test afin d’illustrer comment la méthode Arrays.fill() gère un tableau d’objets.
2.2
Exécutez un programme test afin d’illustrer comment la méthode Arrays.equals() gère un tableau d’objets.
40
Caractéristiques de base des tableaux
2.3
Exécutez un programme test afin d’illustrer comment la méthode Arrays.equals() gère un tableau de tableaux.
2.4
S’il faut 50 minutes à une recherche séquentielle pour parcourir un tableau de 10 000 éléments, combien de temps mettrait-elle pour effectuer la même opération sur un tableau de 20 000 éléments en utilisant le même ordinateur ?
2.5
S’il faut 5 minutes à une recherche binaire pour parcourir un tableau de 1 000 éléments, combien de temps mettrait-elle pour effectuer la même opération sur un tableau de 1 000 éléments en utilisant le même ordinateur ?
2.6
La recherche par interpolation est similaire à la recherche binaire. Cependant, contrairement à cette dernière, elle choisit si au cours de l’étape 4 de façon à ce que la proportion des éléments inférieurs à si dans la sous-séquence ss corresponde à une répartition uniforme. Par exemple, si vous recherchez le nom Byrd dans un annuaire de 2600 pages, vous ouvrirez d’abord celui-ci aux alentours de la page 200 en supposant logiquement qu’1/13e des noms précède celui que vous recherchez. La recherche par interpolation peut être exécutée en O(lglgn). En tenant compte de ces informations, s’il vous a fallu 5 minutes pour exécuter votre recherche sur un tableau de 1 000 éléments, combien de temps mettrez-vous pour un tableau de 1 000 000 éléments en utilisant le même ordinateur ?
2.7
Exécutez un pilote test pour la méthode de recherche binaire présentée dans l’exemple 2.7 sur un tableau de 10 000 éléments et comptez le nombre d’itérations.
2.8
Écrivez et testez la méthode suivante : • private static boolean isSorted(int[] a) • // renvoie true si a[0] <= a[1] <= ... <= a[a.length-1]
2.9
Écrivez et testez la méthode suivante : • private static int minimum(int[] a) • // renvoie l’élément minimum de a[]
2.10 Écrivez et testez la méthode suivante : • private static double mean(double[] a) • // renvoie la valeur moyenne de tous les éléments de a[]
2.11 Écrivez et testez la méthode suivante : • private static int[] withoutDuplicates(int[] a) • // renvoie un tableau avec les mêmes éléments que ceux de a[], • // mais sans copies
2.12 Écrivez et testez la méthode suivante : • private static Object[] withoutDuplicates(Object[] a) • // renvoie un tableau avec les mêmes composants que ceux de a[], • // mais sans copies
2.13 Écrivez et testez la méthode suivante : • private static void reverse(int[] a) • // inverse les éléments de a[]
2.14 Écrivez et testez la méthode suivante : • private static Object[] concatenate(Object[] a, Object[] b) • // renvoie un tableau contenant tous les éléments de a[] • // suivis de tous les éléments de b[]
41
Révision et entraînement
2.15 Écrivez et testez la méthode suivante : • private static void shuffle(Object[] a) • // permute de façon aléatoire les éléments de a[]
2.16 Écrivez et testez la méthode suivante : • private static int[] tally(String string) • // renvoie un tableau a[] de 26 entiers qui compte les fréquences • // des lettres (insensibles à la casse) de la chaîne donnée
2.17 Écrivez et testez la méthode suivante : • private static double innerProduct(double[] x, double[] y) • // renvoie le produit interne algébrique (la sommes des produits • // des composants) des deux tableaux donnés sous forme de • // vecteurs (algébriques)
2.18 Écrivez et testez la méthode suivante : • private static double[][] outerProduct(double[] x, double[] y) • // renvoie le produit externe algébrique des deux tableaux donnés • // sous forme de vecteurs (algébriques) : p[i][j] = a[i]*b[j]
2.19 Écrivez et testez la méthode suivante : • private static double[][] product(double[][] a, double[][] b) • // renvoie le produit matrice des deux tableaux donnés : • // p[i][j] = Sum(a[i][k]*b[k][j]:k)
2.20 Écrivez et testez la méthode suivante : • private static void transpose(double[][] a) • // transpose le tableau donné sous forme de matrice : • // a[i][j] <-- a[j][i]
2.21 Écrivez et testez la méthode suivante : • private static int[][] pascal(int size) • // renvoie le triangle de Pascal avec une taille donnée
2.22 Le crible d’Ératosthène est un tableau d’éléments boolean dont le iième élément est true si et
seulement si i est un nombre premier. Utilisez l’algorithme suivant pour calculer et imprimer un crible de taille 1 000 :
Algorithme 2.3 Crible d’Ératosthène (Condition préalable : p est un tableau de n bits.) (Condition postérieure : p[i] est true si et seulement si i est un nombre premier.) 1. Initialiser p[0] et p[1] à false et tous les autres p[i] à true. 2. Répéter l’étape 3 pour chaque i de 3 à n en incrémentant par 2. 3. S’il existe un nombre premier ≤ à la racine carrée de i qui divise i, paramétrer p[i] à false. 2.23 Répétez l’exercice 2.22 en utilisant l’objet java.util.Vector. 2.24 Répétez l’exercice 2.22 en utilisant l’objet java.util.BitSet. 2.25 Définissez et testez la classe Primes avec les méthodes suivantes : • private Primes() • public static void setLast(int last) • public static void setLast()
// définit le dernier // définit dernier=1
42
Caractéristiques de base des tableaux • public • • public • public • • public • • public
static void sizeSize(int size) // définit la taille // de bitset static void sizeSize() // définit la taille de bitset=1000 static boolean isPrime(int n) // true si n est un // nombre premier static int next() // nombre premier suivant // le dernier static void printPrimes() // imprime le crible
Utilisez l’implémentation BitSet du crible d’Ératosthène de l’exercice 2.24 et les définitions suivantes : • public class Primes • { private static final int SIZE = 1000; • private static int size = SIZE; • private static BitSet sieve = new BitSet(size); • private static int last = 1;
en incluant cet initialisateur statique qui implémente le crible d’Ératosthène : • static • { for (int i=2; i<SIZE; i++) • sieve.set(i); • for (int n=2; 2*n<SIZE; n++) • if (sieve.get(n)) • for (int m=n; m*n<SIZE; m++) • sieve.clear(m*n); •}
2.26 Ajoutez la méthode suivante à la classe Primes, puis testez-la : • public static String factor(int n) • // condition préalable : n > 1 • // renvoie la factorisation des nombres premiers de n; • // exemple : facteur(4840) renvoie "2*2*2*5*11*11"
2.27 Christian Goldbach (1690–1764) a supposé en 1742 que chaque nombre pair supérieur à 2 est la
somme de deux nombres premiers. Écrivez un programme qui teste la conjecture de Goldbach pour tous les nombres pairs inférieurs à 100. Utilisez la classe Primes de l’exercice 2.25. Les 10 premières lignes de la sortie obtenue devraient ressembler aux lignes suivantes : • • • • • • • • • • •
4 = 2+2 6 = 3+3 8 = 3+5 10 = 3+7 = 5+5 12 = 5+7 14 = 3+11 = 7+7 16 = 3+13 = 5+11 18 = 5+13 = 7+11 20 = 3+17 = 7+13 22 = 3+19 = 5+17 = 11+11
2.28 D’après les travaux de Pierre de Fermat (1601–1665), il existe un nombre infini de nombres prep 2
miers de forme n = 2 + 1 pour un entier p. Ces nombres sont qualifiés de nombres premiers 1 2 de Fermat. Par exemple, 5 est un nombre premier de Fermat parce qu’il a la forme 2 + 1 . Écrivez un programme capable de rechercher tous les nombres premiers de Fermat se trouvant dans l’intervalle du type int. Utilisez la classe Primes de l’exercice 2.25 et la méthode Math.pow.
43
Révision et entraînement
Les cinq premières lignes de votre sortie devraient ressembler aux lignes suivantes : • • • • • •
2^2^0 2^2^1 2^2^2 2^2^3 2^2^4
+ + + + +
1 1 1 1 1
= = = = =
3 5 17 257 65537
2.29 Charles Babbage (1792–1871) a obtenu la première bourse jamais accordée en 1823 lorsqu’il a
persuadé le gouvernement britannique de lui accorder 1 000 livres pour qu’il puisse construire sa machine de calcul mécanique. Dans sa demande de bourse, Babbage donnait la formule x2 + x + 41 comme exemple d’une fonction que sa machine serait en mesure de calculer. Cette fonction présentait un intérêt particulier pour les mathématiciens parce qu’elle crée un nombre inhabituel de nombres premiers. Les nombres premiers de forme n = x2 + x + 41 pour un entier x sont qualifiés de nombres premiers de Babbage. Écrivez un programme capable de retrouver tous les nombres premiers de Babbage inférieurs à 10 000. Utilisez la classe Primes de l’exercice 2.25. Les cinq premières lignes de la sortie obtenue devraient ressembler aux lignes suivantes : • • • • • •
0 1 2 3 4
41 43 47 53 61
est est est est est
un un un un un
nombre nombre nombre nombre nombre
premier premier premier premier premier
2.30 Deux entiers impairs consécutifs qui sont tous les deux premiers sont qualifiés de nombres pre-
miers jumeaux. La conjecture des nombres premiers jumeaux consiste à dire qu’il existe un nombre infini de nombres premiers jumeaux. Écrivez un programme capable de rechercher tous les nombres premiers jumeaux inférieurs à 1 000. Utilisez la classe Primes de l’exercice 2.25. Les cinq premières lignes de la sortie obtenue devraient ressembler aux lignes suivantes : • • • • • •
3 5 5 7 11 13 17 19 29 31
2.31 Testez la supposition selon laquelle il existe au moins un nombre premier entre chaque paire de
nombres aux carrés consécutifs (les nombres au carré sont 1, 4, 9, 16, 25, …). Utilisez la classe Primes de l’exercice 2.25. Les cinq premières lignes de la sortie obtenue devraient ressembler aux lignes suivantes : • • • • • •
1 < 2 < 4 4 < 5 < 9 9 < 11 < 16 16 < 17 < 25 25 < 29 < 36
2.32 Le moine minime Marin Mersenne (1588–1648) entreprit en 1644 l’étude de nombres sous la
forme n = 2p – 1, p étant un nombre premier. Il était convaincu que la plupart de ces nombres n étaient premiers. Ces nombres sont maintenant appelés Nombres premiers de Mersenne. Écrivez un programme capable de rechercher tous les nombres premiers de Mersenne pour p < 30.
44
Caractéristiques de base des tableaux
Utilisez la classe Primes de l’exercice 2.25. Les cinq premières lignes de la sortie obtenue devraient ressembler aux lignes suivantes : • • • • • •
2 2^2-1 = 3 2^3-1 = 5 2^5-1 = 7 2^7-1 = 11 2^11-1
3 est un nombre premier 7 est un nombre premier 31 est un nombre premier 127 est un nombre premier = 2047 est un nombre premier
2.33 Un nombre est dit palindromique s’il ne varie pas lorsqu’il est inversé, c’est-à-dire s’il reste le
même lorsque les chiffres qui le composent sont inversés. Par exemple, 3456543 est palindromique. Écrivez un programme capable de vérifier chacun des 10 000 premiers nombres premiers et d’imprimer ceux qui sont palindromiques. Utilisez la classe Primes de l’exercice 2.25.
¿
SOLUTIONS
SOLUTIONS
2.1
Le programme test de la méthode java.util.Arrays.fill() appliquée aux tableaux d’objets est le suivant : • import java.util.Arrays; • public class Pr0201 • { public static void main(String[] args) • { Object[] a = new Object[4]; • Double x = new Double(Math.PI); • Arrays.fill(a,x); • for (int i=0; i
2.2
Le programme test de la méthode java.util.Arrays.equals() appliquée aux tableaux d’objets est le suivant : • import java.util.Arrays; • public class Pr0202 • { public static void main(String[] args) • { Double x = new Double(Math.PI); • Object[] a = new Object[4]; • Arrays.fill(a,x); • Object[] b = new Object[4]; • Arrays.fill(b,x); • System.out.println("b.equals(a) = " + b.equals(a)); • System.out.println("Arrays.equals(a,b) = " • + Arrays.equals(a,b)); • Arrays.fill(a,"Eclair au chocolat !"); • Arrays.fill(b,"Eclair au chocolat !"); • System.out.println("b.equals(a) = " + b.equals(a)); • System.out.println("Arrays.equals(a,b) = " • + Arrays.equals(a,b)); • } •}
Révision et entraînement
2.3
45
Le programme test de la méthode java.util.Arrays.equals() appliquée à des tableaux de tableaux est le suivant : • import java.util.Arrays; • public class Pr0203 • { public static void main(String[] args) • { double[] x = { Math.E, Math.PI }; • String[] s = { "Nord", "Est", "Sud", "Ouest" }; • Vector[] y = new Vector[0]; • Object[] a = { x, s, null, y }; • Object[] b = { x, s, null, y }; • System.out.println("b.equals(a) = " + b.equals(a)); • System.out.println("Arrays.equals(a,b) = " • + Arrays.equals(a,b)); • } •}
2.4
2.5
2.6
2.7
La recherche séquentielle est exécutée de façon linéaire, ce qui signifie que sa durée est proportionnelle au nombre d’éléments. Par conséquent, le traitement d’un tableau deux fois plus grand prendrait deux fois plus de temps, soit 20 minutes. La recherche binaire est exécutée de façon logarithmique, c’est pourquoi la mise au carré de la taille du tableau ne fait que doubler la durée du traitement. Ainsi, un tableau composé de 1 0002 éléments sera traité en deux fois plus de temps, soit 10 minutes. La recherche par interpolation a une durée d’exécution hyperlogarithmique. Par conséquent, la mise au carré de la taille du tableau n’affecte en aucun cas cette durée d’exécution de la recherche qui sera d’environ 2 minutes. Le programme test de l’algorithme de recherche séquentielle est le suivant : • public class Pr0207 • { private static final int N=16; • private static int[] a = new int[N]; • private static final int RANGE=2*N; • private static final int START=10; • private static Random random = new Random(); • public static void main(String[] args) • { load(a); • print(a); • int x = random.nextInt(RANGE) + START; • System.out.println("x = " + x); • int i = sequentialSearch(a,x); • System.out.println("recherche(a,x) = " + i); • if (i >= 0) System.out.println("a[" + i + "] = " + a[i]); • } • private static void load(int[] a) • { for (int i=0; i9?"":" ") + i); • System.out.print("\n{ " + a[0]); • for (int i=1; i
46
Caractéristiques de base des tableaux • if (a[i]==x) return i; • return -1; • } •}
2.8
Le programme test de la méthode isSorted(int[]) est le suivant : • public class Pr0208 • { private static final int SIZE = 16; • private static int[] a = new int[SIZE]; • public static void main(String[] args) • { schaums.dswj.Arrays.load(a,40,20); • schaums.dswj.Arrays.print(a); • System.out.println("isSorted(a) = " + isSorted(a)); • java.util.Arrays.sort(a); • schaums.dswj.Arrays.print(a); • System.out.println("isSorted(a) = " + isSorted(a)); • } • private static boolean isSorted(int[] a) • { if (a.length<2) return true; • for (int i=1; i
2.9
Le programme test de la méthode minimum(int[]) est le suivant : • public class Pr0209 • { private static final int SIZE = 8; • private static int[] a = new int[SIZE]; • public static void main(String[] args) • { schaums.dswj.Arrays.load(a,20,80); • schaums.dswj.Arrays.print(a); • System.out.println("minimum(a) = " + minimum(a)); • } • private static int minimum(int[] a) • { int min = a[0]; • for (int i=1; i
2.10 Le programme test de la méthode mean(double[]) est le suivant : • public class Pr0210 • { private static final int SIZE = 4; • private static double[] a = new double[SIZE]; • public static void main(String[] args) • { schaums.dswj.Arrays.load(a,20,10); • schaums.dswj.Arrays.print(a); • System.out.println("mean(a) = " + mean(a)); • } • private static double mean(double[] a) • { double sum=0.0; • for (int i=0; i
Révision et entraînement
2.11 Le programme test de la méthode withoutDuplicates(int[]) est le suivant : • public class Pr0211 • { private static final int SIZE = 16; • private static int[] a = new int[SIZE]; • public static void main(String[] args) • { schaums.dswj.Arrays.load(a,10,8); • schaums.dswj.Arrays.print(a); • int[] b = withoutDuplicates(a); • schaums.dswj.Arrays.print(b); • } • private static int[] withoutDuplicates(int[] a) • { if (a.length<2) return a; // il n’y a aucune copie • int x = a[0]; // utiliser cette valeur comme marqueur factice • for (int i=1; i0 && a[i] != x) b[i-shift] = a[i]; • else if (a[i]==x) ++shift; • else b[i] = a[i]; • return b; • } •}
2.12 Le programme test de la méthode withoutDuplicates(Object[]) est le suivant : • public class Pr0212 • { private static final int SIZE = 16; • private static Object[] a = new Object[SIZE]; • public static void main(String[] args) • { schaums.dswj.Arrays.load(a,10,8); • schaums.dswj.Arrays.print(a); • Object[] b = withoutDuplicates(a); • schaums.dswj.Arrays.print(b); • } • private static Object[] withoutDuplicates(Object[] a) • { if (a.length<2) return a; // il n’y a aucune copie • Object x = a[0]; // utiliser cet objet comme marqueur factice • for (int i=1; i0 && !a[i].equals(x)) b[i-shift] = a[i]; • else if (a[i].equals(x)) ++shift; • else b[i] = a[i];
47
48
Caractéristiques de base des tableaux • return b; • } •}
2.13 Le programme test de la méthode reverse(int[]) est le suivant : • public class Pr0213 • { private static final int SIZE = 16; • private static int[] a = new int[SIZE]; • public static void main(String[] args) • { schaums.dswj.Arrays.load(a,60,40); • schaums.dswj.Arrays.print(a); • reverse(a); • schaums.dswj.Arrays.print(a); • } • private static void reverse(int[] a) • { if (a.length<2) return; • for (int i=0; i
2.14 Le programme test de la méthode concatenate(Object[],Object[]) est le suivant : • public class Pr0214 • { private static final int SIZE = 8; • private static Object[] a = new Object[SIZE]; • private static Object[] b = new Object[SIZE]; • public static void main(String[] args) • { schaums.dswj.Arrays.load(a,10,40); • schaums.dswj.Arrays.load(b,60,40); • schaums.dswj.Arrays.print("a",a); • schaums.dswj.Arrays.print("b",b); • Object[] c = concatenate(a,b); • schaums.dswj.Arrays.print("a",a); • schaums.dswj.Arrays.print("b",b); • schaums.dswj.Arrays.print("c",c); • } • private static Object[] concatenate(Object[] a, Object[] b) • { Object[] c = new Object[a.length+b.length]; • for (int i=0; i
2.15 Le programme test de la méthode shuffle(Object[]) est le suivant : • public class Pr0215 • { private static final int SIZE = 16; • private static Object[] a = new Object[SIZE]; • • public static void main(String[] args) • { schaums.dswj.Arrays.load(a,10,90); • schaums.dswj.Arrays.print(a); • shuffle(a); • schaums.dswj.Arrays.print(a); • } • private static void shuffle(Object[] a)
Révision et entraînement • { Random random = new Random(); • for (int i=0; i
2.16 Le programme test de la méthode tally(String) est le suivant : • public class Pr0216 • { public static void main(String[] args) • { String string="Bienvenue dans le nouveau millénaire"; • System.out.println(string); • int[] t = tally(string); • for (int i=0; i<26; i++) • System.out.println("Fréquence de " + (char)(’A’+i) • + " = " + t[i]); • } • private static int[] tally(String s) • { int[] frequency = new int[26]; • for (int i=0; i<s.length(); i++) • { char ch = Character.toUpperCase(s.charAt(i)); • if (Character.isLetter(ch)) • ++frequency[(int)ch - (int)’A’]; // compter ch • } • return frequency; • } •}
2.17 Le programme test de la méthode innerProduct(double[],double[]) est le suivant : • public class Pr0217 • { public static void main(String[] args) • { double[] x = { 1.1, 2.2, 3.3, 4.4 }; • double[] y = { 2.0, 0.0, 1.0, -1.0 }; • System.out.println("innerProduct(x,y) = " • + innerProduct(x,y)); • } • private static double innerProduct(double[] x, double[] y) • { double sum=0.0; • for (int i=0; i<x.length && i
2.18 Le programme test de la méthode outerProduct(double[],double[]) est le suivant : • public class Pr0218 • { public static void main(String[] args) • { double[] x = { 1.1, 2.2, 3.3, 4.4 }; • double[] y = { 2.0, 0.0, -1.0 }; • double[][] z = outerProduct(x,y); • for (int i=0; i<x.length; i++) • { for (int j=0; j
49
50
Caractéristiques de base des tableaux • for (int j=0; j
2.19 Le programme test de la méthode product(double[][],double[][]) est le suivant : • public class Pr0219 • { public static void main(String[] args) • { double[][] x = { { 1.0, 2.0 }, • { 3.0, 4.0 } }; • double[][] y = { { 20.0, -10.0 }, • { 10.0, 20.0 } }; • double[][] z = product(x,y); • for (int i=0; i<x.length; i++) • { for (int j=0; j
2.20 Le programme test de la méthode transpose(double[][]) est le suivant : • public class Pr0220 • { public static void main(String[] args) • { double[][] x = { { 1.0, 2.0, 3.0 }, { 4.0, 5.0, 6.0 } }; • double[][] y = transpose(x); • for (int i=0; i
2.21 Le programme test qui renvoie le triangle de Pascal est le suivant : • public class Pr0221 • { private static final int N=9; • public static void main(String[] args) • { int[][] p = pascal(N);
Révision et entraînement • • • • • • • • • • • • • • • •}
for (int i=0; i
2.22 Le crible d’Ératosthène est le suivant : • public class Pr0222 • { private static final int SIZE=1000; • private static boolean[] sieve = new boolean[SIZE]; • public static void main(String[] args) • { initializeSieve(); • printSieve(); • } • private static void initializeSieve() • { for (int i=2; i<SIZE; i++) • sieve[i] = true; • for (int n=2; 2*n<SIZE; n++) • if (sieve[n]) • for (int m=n; m*n<SIZE; m++) • sieve[m*n] = false; • } • private static void printSieve() • { int n=0; • for (int i=0; i<SIZE; i++) • if (sieve[i]) System.out.print((n++%10==0?"\n":"\t")+i); • System.out.println("\n" + n • + " nombres premiers inférieurs à "+ SIZE); • } •}
2.23 Le crible d’Ératosthène avec un objet java.util.Vector est le suivant : • import java.util.Vector; • public class Pr0223 • { private static final int SIZE=1000; • private static Vector sieve = new Vector(SIZE); • public static void main(String[] args) • { initializeSieve(); • printSieve(); • } • private static void initializeSieve() • { sieve.add(Boolean.FALSE); • sieve.add(Boolean.FALSE); • for (int i=2; i<SIZE; i++) • sieve.add(Boolean.TRUE); • for (int n=2; 2*n<SIZE; n++) • if (((Boolean)sieve.get(n)).booleanValue()) • for (int m=n; m*n<SIZE; m++)
51
52
Caractéristiques de base des tableaux • • • • • • • • • • • •}
sieve.set(m*n,Boolean.FALSE); } private static void printSieve() { int n=0; for (int i=0; i<SIZE; i++) if (((Boolean)sieve.get(i)).booleanValue()) System.out.print((n++%10==0?"\n":"\t")+i); System.out.println("\n" + n + " nombres premiers inférieurs à " + SIZE); }
2.24 Le crible d’Ératosthène avec un objet java.util.BitSet : • import java.util.BitSet; • public class Pr0224 • { private static final int SIZE=1000; • private static BitSet sieve = new BitSet(SIZE); • public static void main(String[] args) • { initializeSieve(); • printSieve(); • } • private static void initializeSieve() • { for (int i=2; i<SIZE; i++) • sieve.set(i); • for (int n=2; 2*n<SIZE; n++) • if (sieve.get(n)) • for (int m=n; m*n<SIZE; m++) • sieve.clear(m*n); • } • private static void printSieve() • { int n=0; • for (int i=0; i<SIZE; i++) • if (sieve.get(i)) • System.out.print((n++%10==0?"\n":"\t")+i); • System.out.println("\n" + n • + " nombres premiers inférieurs à " + SIZE); • } •}
2.25 La classe Primes est définie de la façon suivante : • package schaums.dswj; • import java.util.*; • public class Primes • { private static final int SIZE = 1000; • private static int size = SIZE; • private static BitSet sieve = new BitSet(size); • private static int last = 1; • static • { for (int i=2; i<SIZE; i++) • sieve.set(i); • for (int n=2; 2*n<SIZE; n++) • if (sieve.get(n)) • for (int m=n; m*n<SIZE; m++) • sieve.clear(m*n); • } • private Primes() • { • }
Révision et entraînement • public static void setLast(int n) • { last = n; • } • public static void setLast() • { last = 1; • } • public static void setSize(int n) • { size = n; • } • public static void setSize() • { size = 1000; • } • public static boolean isPrime(int n) • { return sieve.get(n); • } • public static int next() • { while (++last<size) • if (sieve.get(last)) return last; • return -1; • } • public static void printPrimes() • { int n=0; • for (int i=0; i<SIZE; i++) • if (sieve.get(i)) • System.out.print((n++%10==0?"\n":"\t")+i); • System.out.println("\n" + n • + " nombres premiers inférieurs à " + SIZE); • } •} • • import schaums.dswj.Primes; • public class Pr0225 • { public static void main(String[] args) • { Primes.printPrimes(); • for (int n=1; n<=10; n++) • System.out.println(n + ".\t" + Primes.next()); • } •}
2.26 Le programme test de la méthode de factorisation des nombres premiers est le suivant : • import schaums.dswj.Primes; • import java.util.Random; • public class Pr0226 • { private static final int N=10; • private static final int RANGE=2000; • private static Random random = new Random(); • public static void main(String[] args) • { for (int i=0; i
La méthode est ajoutée de la façon suivante à la classe Primes : • public static String factor(int n) • { String primes=""; • int p = next(); • while (n>1)
53
54
Caractéristiques de base des tableaux • • • • • • • • • • • • •}
{ if (n%p==0) { primes += (primes.length()==0?"":"*") + p; n /= p; } else p = next(); if (p == -1) { primes += " DEBORDEMENT"; break; } } setLast(); return primes;
2.27 Le programme test de la conjecture de Goldbach est le suivant : • public class Pr0227 • { public static void main(String[] args) • { final int N=10000; • Primes.setSize(N); • System.out.println("4 = 2+2"); • for (int n=6; n<100; n += 2) • { System.out.print(n); • for (int p=3; p<=n/2; p += 2) • if (Primes.isPrime(p) && Primes.isPrime(n-p)) • System.out.print(" = "+p+"+"+(n-p)); • System.out.println(); • } • } •}
2.28 Le programme de recherche des nombres premiers de Fermat est le suivant : • public class Pr0228 • { public static void main(String[] args) • { final int N=10000; • Primes.setSize(N); • for (int p=0; p<5; p++) • { int n = (int)Math.pow(2,Math.pow(2,p)) + 1; • if (Primes.isPrime(n)) • System.out.println("p = "+p+", n = 2^2^p = "+n); • } • } •}
2.29 Le programme de recherche des nombres premiers de Babbage est le suivant : • public class Pr0229 • { public static void main(String[] args) • { final int N=10000; • Primes.setSize(N); • for (int x=0; x<50; x++) • { System.out.print(x); • int n = x*x + x + 41; • if (Primes.isPrime(n)) • System.out.println("\t"+n+" is prime"); • else System.out.println(); • } • } •}
Révision et entraînement
2.30 Le programme de recherche des nombres premiers jumeaux est le suivant : • public class Pr0230 • { public static void main(String[] args) • { final int N=1000; • Primes.setSize(N); • int n=Primes.next(); • while (n<0.9*N) • { if (Primes.isPrime(n+2)) • System.out.println(n + "\t" + (n+2)); • n = primes.next(); • } • } •}
2.31 Le programme de recherche des nombres premiers entre les racines carrées est le suivant : • public class Pr0231 • { public static void main(String[] args) • { final int N=10000; • Primes.setSize(N); • for (int n=1; n<100; n++) • for (int i=n*n+1; i<(n+1)*(n+1); i++) • if (Primes.isPrime(i)) • { System.out.println(n*n + " < " + i + " < " + (n+1)*(n+1)); • break; • } • } •}
2.32 Le programme de recherche des nombres premiers de Mersenne est le suivant : • public class Pr0232 • { public static void main(String[] args) • { final int N=10000; • Primes.setSize(N); • for (int p = Primes.next(); p<30; p = Primes.next()) • { int n = (int)Math.round(Math.pow(2,p)) - 1; • System.out.print(p + "\t2^" + p + "-1 = " + n); • if (Primes.isPrime(n)) • System.out.println(" est un nombre premier "); • else System.out.println(" n’est pas un nombre premier "); • } • } •}
2.33 Le programme de recherche des nombres premiers palindromiques est le suivant : • public class Pr0233 • { public static void main(String[] args) • { final int N=10000; • Primes.setSize(N); • for (int i=0; i
55
56
Caractéristiques de base des tableaux • • • • • • • • • • • • • } •}
// faire de p10 la puissance 10 la plus importante < n while (p109) { if (n/p10 != n%10) return false; n /= 10; // supprimer de n le chiffre le plus à droite p10 /= 10; n %= p10; // supprimer de n le chiffre le plus à gauche } return true; // les entiers composés d’un chiffre sont // palindromiques
Chapitre 3
Java avancé 3.1 HÉRITAGE L’héritage des classes représente l’un des concepts centraux de la programmation orientée objet. Nous disons que la classe Y hérite de la classe X si elle étend cette dernière en utilisant ses champs et ses méthodes en plus de la définition de ses propres champs et méthodes. Dans ce cas, nous disons également que Y est une sous-classe de X ou bien une classe enfant de X qui est alors qualifiée de classe parent ou superclasse. D’un point de vue conceptuel, vous obtenez ainsi des instances de la classe Y qui sont plus spécialisées et des instances de la classe X qui sont plus générales.
Exemple 3.1 Étendre la classe Point Le programme suivant définit PointColore comme sous-classe de la classe Point déjà vue dans l’exemple 1.7 : public class PointColore extends Point { private String couleur="noir"; public PointColore(double x, double y, String couleur) { super(x,y); // appelle le constructeur parent this.couleur = couleur; } public String getCouleur() { return couleur; } public void setCouleur(String couleur) { this.couleur = couleur; } public boolean equals(Object object) { if (object == this) return true; if (object.getClass() != this.getClass()) return false; if (object.hashCode() != this.hashCode()) return false; PointColore point = (PointColore)object; return (x == point.x && y == point.y && couleur == point.couleur); }
58
Java avancé
public int hashCode() { return (new Double(x)).hashCode() + (new Double(y)).hashCode() + couleur.hashCode(); } public String toString() { return new String("(" + x + "," + y + ", " + couleur + ")"); } }
Cette sous-classe définit son propre constructeur, un nouvel accesseur getCouleur() et un nouveau mutateur setCouleur(String). Elle remplace les méthodes equals(Object), hashCode() et toString() définies dans la classe parent. Remarquez que les champs x et y de la classe Point doivent être déclarés comme protected au lieu de private afin d’être accessibles depuis la sous-classe PointColore. Voici le pilote test de cette sous-classe : public class Ex0301 { public static void main(String[] args) { PointColore p = new PointColore(2,3,"vert"); System.out.println("p = " + p); PointColore q = new PointColore(2,3,"vert"); System.out.println("q = " + q); if (q == p) System.out.println("q == p"); else System.out.println("q != p"); if (q.equals(p)) System.out.println("q est égal à p"); else System.out.println("q n’est pas égal à p"); q.setCouleur("rouge"); System.out.println("q = " + q); if (q.equals(p)) System.out.println("q est égal à p"); else System.out.println("q n’est pas égal à p"); } } p q q q q q
= (2.0,3.0, vert) = (2.0,3.0, vert) != p est égal à p = (2.0,3.0, rouge) n’est pas égal à p
3.2 POLYMORPHISME Grâce à l’héritage, l’instance d’une sous-classe peut-être considérée comme une instance de sa classe parent lorsqu’elle est passée sous forme d’un argument à une méthode. Cette capacité de prendre en apparence plusieurs formes est qualifiée de polymorphisme.
Exemple 3.2 Utiliser le polymorphisme public class Ex302 { public static void main(String[] args) { PointColore p = new PointColore(2,3,"vert"); System.out.println("p = " + p); Point q = new Point(-2,0); System.out.println("q = " + q); System.out.println("distance(p,q) = " + distance(p,q)); }
59
Polymorphisme
private static double distance(Point p, Point q) { double dx = p.getX() - q.getX(); double dy = p.getY() - q.getY(); return Math.sqrt(dx*dx + dy*dy); } } p = (2.0,3.0, vert) q = (-2.0,0.0) distance(p,q) = 5.0
L’objet p est une instance de la classe PointColore. Mais la méthode distance(Point,Point) permet son passage au premier paramètre sous forme d’une instance de la classe parent Point. C’est pourquoi p semble avoir plusieurs formes (PointColore et Point), c’est-à-dire qu’il semble être polymorphique. Toutes les classes Java, qu’elles fassent partie de la bibliothèque standard ou qu’elles soient créées par le programmeur, résident dans une hiérarchie d’héritage de grande taille. Cette hiérarchie se présente sous la forme d’une structure arborescente avec la classe java.lang.Object à sa racine. Chaque autre classe se trouve sous une classe parent unique. Ainsi, chaque classe Java est directement ou indirectement une sous-classe de la classe Object. L’arbre ci-contre illustre l’organisation de 40 des 1 462 classes qui constituent la bibliothèque standard Java 1.2 (soit moins de 3 % d’entre elles). Vous pouvez notamment constater que Integer est une sous-classe de Number, qui est une sousclasse de la classe Object. Cet arbre qui illustre la hiérarchie Java vous permet également de comprendre comment fonctionne le polymorphisme. Étant donné que les instances de chaque classe enfant peuvent être passées à un paramètre dont le type est une classe ancêtre, il suffit simplement de suivre les chemins qui vont des feuilles à la racine Object pour voir à quoi ressemble un objet polymorphique. Par exemple, un objet Frame peut être passé à un paramètre de type Frame, Window, Container, Component ou Object. En raison de cette hiérarchie Java, le polymorphisme signifie que tout objet peut être passé à un paramètre de type Object et que tout objet peut appeler n’importe quelle méthode définie dans la classe Object (puisqu’aucune d’entre elles n’est private).
Object AbstractCollection AbstractList AbstractSequentialList LinkedList ArrayList Vector Stack AbstractSet HashSet TreeSet AbstractMap HashMap TreeMap WeakHashMap Arrays BitSet Collections Component Button Container Panel Window Frame Date Dictionary Hashtable Properties File Math Number Integer Double Random Reader InputStreamReader FileReader String StringTokenizer System
60
Java avancé
3.3 CONVERSION DES TYPES Dans le cadre de Java, chaque expression a un type qui peut être converti à l’aide de différents mécanismes. Conversions primitives élargissantes
Conversions primitives rétrécissantes double
float
float
long
long
int
int
char
short byte
short char
byte
L’opérateur de concaténation + de type String convertit automatiquement les autres types en String, comme dans l’exemple suivant : int n = 44; String s = "n = " + n;
Dans l’expression "n = " + n, l’opérateur + convertit int n en objet String "44". Ce procédé est qualifié de conversion de chaîne. Si le type de la classe est différent de String, la méthode toString() de cette classe est appelée pour effectuer la conversion. Cette opération peut être héritée de la classe Object. Lorsque plusieurs types numériques sont utilisés dans une expression numérique, les valeurs de type les plus petites sont automatiquement converties en valeurs de type plus grandes, par exemple : double x = 3.14159/4;
L’expression 3.14159/4 contient la valeur double 3.14159 et la valeur 4 de type int ; c’est pourquoi la valeur int est convertie en type double avant l’opération de division. Il s’agit d’une promotion numérique. Le même processus de conversion a lieu lorsqu’un type plus petit est affecté à un type plus grand, comme dans l’exemple suivant : double x = 44;
Cette initialisation affecte la valeur 44 de type int à la variable x de type double. Avant l’affectation, la valeur int est convertie dans son équivalent de type double. Il s’agit de la conversion de l’affectation. Cette technique peut également être utilisée entre des types de référence :
Exemple 3.3 Conversion de l’affectation class X { int a; } class Y extends X { int b; } public class Ex0303 { public static void main(String[] args) { X x = new X(); System.out.println("x.getClass() = "+ x.getClass()); Y y = new Y(); System.out.println("y.getClass() = "+ y.getClass()); x = y; // conversion de l’affectation de x en type Y
Conversion des types
61
System.out.println("x.getClass() = "+ x.getClass()); } } x.getClass() = class X y.getClass() = class Y x.getClass() = class Y
L’affectation x = y attribue le type le plus petit Y au type le plus grand X et convertit ainsi x en type Y. Le polymorphisme décrit dans la section 2.3 est qualifié de conversion de l’appel de méthode parce qu’un type est converti dans un autre lorsqu’il est passé à une méthode appelée. Ce type de conversion a également lieu avec les types primitifs. Par exemple : int n = 44; double y = Math.sqrt(n); // conversion de l’appel de méthode
Dans le cas présent, la valeur 44 de type int est convertie en double lorsque la méthode Math.sqrt(double) est appelée parce que son paramètre est de type double. Pour finir, il reste à préciser que les types peuvent être convertis explicitement à l’aide de l’opérateur de conversion de type.
Exemple 3.4 Transtyper les types de référence class X { public String toString() { return "Je suis un X."; } } class Y extends X { public String toString() { return "Je suis un Y."; } } public class Ex0304 { public static void main(String[] args) { Y y = new Y(); System.out.println("y: " + y); X x = y; System.out.println("x: " + x); Y yy = (Y)x; // transtype x en type Y System.out.println("yy: " + yy); X xx = new X(); System.out.println("xx: " + xx); yy = (Y)xx; // Erreur d’exécution : xx ne peut pas être // transtypé en y System.out.println("yy: " + yy); } } y: Je suis un Y. x: Je suis un Y. yy: Je suis un Y. xx: Je suis un X. Exception in thread "main" java.lang.ClassCastException: X at Testing.main(Testing.java)
La conversion yy = (Y)x convertit x en type Y. Cette opération fonctionne parce que la valeur de x peut être interprétée pour le type Y étant donné qu’elle provient initialement de y. La conversion yy = (Y)xx convertit xx en type Y. La compilation a lieu mais, au moment de l’exécution, l’exception ClassCastException est lancée parce que la valeur de xx ne peut pas être interprétée pour le type Y.
62
Java avancé
Le transtypage de l’exemple 3.4 illustre des conversions rétrécissantes de types de référence se soldant par une réussite ou par un échec. L’exemple suivant vous permettra de constater qu’il est également possible d’effectuer des conversions rétrécissantes de types primitifs réussies ou non.
Exemple 3.5 Transtyper les types primitifs public class Ex0305 { public static void main(String[] args) { double x = 44.0; System.out.println("x = " + x); float y = (float)x; // transtypage rétrécissant de double en float System.out.println("y = " + y); int n = (int)y; // transtypage rétrécissant de float en int System.out.println("n = " + n); short m = (short)n; // transtypage rétrécissant de int en short System.out.println("m = " + m); n = 65536 + 4444; System.out.println("n = " + n); m = (short)n; // transtypage rétrécissant de int en short System.out.println("m = " + m); y = (float)m; // transtypage élargissant de short en float System.out.println("y = " + y); y = (float)n; // transtypage élargissant de int en float System.out.println("y = " + y); } } x y n m n m y y
= = = = = = = =
44.0 44.0 44 44 69980 4444 4444.0 69980.0
Les trois premiers transtypages rétrécissants sont réussis parce que la valeur 44 est appropriée pour les types les plus petits. Cependant, la valeur int 69980 (65536 + 4444) n’est pas transtypée en short : la valeur erronée 4444 est affectée à m. En effet, le rétrécissement de int en short crée toujours le reste issu de la division de la valeur int par 65 536, soit 216. De la même façon, le transtypage élargissant y = (float)m de short en float est réussi tandis que le transtypage élargissant y = (float)n de int en float échoue parce que la valeur int 69980 comprend trop de chiffres significatifs pour le type float. Remarquez que cette valeur numérique est identique à celle obtenue en rétrécissant int en short.
3.4 CLASSE Object La classe Object est la classe ancêtre dominante en Java. Toutes les autres classes en sont dérivées. Chaque méthode de la classe Object est héritée par toutes les autres classes. Vous trouverez ci-après la liste des méthodes les plus importantes : public class Object { protected Object clone() public boolean equals(Object) public final Class getClass()
63
Classe Object
protective int hashCode() public Object() public String toString() }
La plupart de ces méthodes seront remplacées par des sous-classes. La méthode clone() renvoie une copie de l’objet. Si la sous-classe ne remplace pas cette méthode, elle se contente d’effectuer une copie champ par champ.
Exemple 3.6 Clonage incorrect class Widget implements Cloneable { int n; Widget w; Widget(int n) { this.n = n; } public Object clone() throws CloneNotSupportedException { return super.clone(); } public String toString() { return "(" + n + "," + w.n + ")"; } } public class Ex0206 { public static void main(String[] args) throws CloneNotSupportedException { Widget x = new Widget(44); x.w = new Widget(66); System.out.println("x = " + x); Widget y = (Widget)x.clone(); System.out.println("y = " + y); x.n = 55; x.w.n = 77; System.out.println("x = " + x); System.out.println("y = " + y); } } xx yy xx yy r
= = = =
(44,66) (44,66) (55,77) (44,77)
n
44 int
x Widget
w Widget
n
66 int
Le widget x est construit avec le champ n w n 44 initialisé à 44. Puis le champ w est instanWidget int y cié directement dans la deuxième ligne, Widget ce qui permet d’initialiser x.w.n à 66. w Le widget y est construit comme clone Widget de x. La méthode Object.clone() copie simplement les champs n et w de x, sans instancier d’autre widget pour y.w. C’est la raison pour laquelle le widget référencé par x.w n’est pas copié. Lorsque x.n prend la valeur 55, cela n’affecte en aucun cas y.n qui conserve sa valeur 44. Mais lorsque x.w.n prend la valeur 77, il s’agit également d’une valeur de y.w.n, c’est pourquoi y n’est pas complètement indépendant de x. Le clonage est donc incomplet.
64
Java avancé
Exemple 3.7 Clonage correct Essayons maintenant de remplacer la méthode clone() de l’exemple 3.6 par le programme suivant : public Object clone() throws CloneNotSupportedException { Widget newWidget = new Widget(this.n); Widget y = newWidget; Widget t = this.w; while (t != null) { y.w = new Widget(t.n); y = y.w; t = t.w; } return newWidget; } xx yy xx yy
= = = =
(44,66) (44,66) (55,77) (44,66)
Ce programme ne copie pas uniquement le widget, mais également chaque widget associé au widget this. C’est la raison pour laquelle aucun widget cloné n’est complètement indépendant de ce widget. Par conséquent, la modification d’un widget n’a aucun effet sur l’autre.
n
55
n
77
int
x
int
Widget
w
w
Widget
Widget
n
44
n
66
int
y
int
Widget
w
w
Widget
Widget
La méthode equals() doit être remplacée de la même façon que la méthode clone(). Tous les éléments liés correspondants doivent être comparés (reportez-vous à l’exemple 1.7 et à l’exercice d’entraînement 3.4). La méthode getClass() renvoie un objet Class qui représente la classe instanciée par l’objet this. Elle est particulièrement utile lorsque vous souhaitez tester l’égalité des objets (reportez-vous à l’exemple 1.7 et à l’exercice d’entraînement 3.4). La méthode hashCode() renvoie un int qui fonctionne comme un code d’identification de l’objet. Les hash codes de différents objets sont susceptibles de varier. Ceux des objets composés doivent être calculés à partir des hash codes de leurs composants (reportez-vous à l’exemple 1.7 et à l’exercice d’entraînement 3.5). La méthode toString() renvoie un type String qui affiche le contenu de l’objet (reportez-vous aux exemples 1.7 et 3.6).
3.5 CLASSES ABSTRAITES Une classe abstraite comprend au moins une méthode abstraite. Une méthode abstraite ne comporte pas d’implémentation, mais uniquement une déclaration d’en-tête. C’est le mot-clé abstract permet d’identifier les classes et les méthodes abstraites.
Exemple 3.8 Classe Sequence déclarée comme abstract public abstract class Sequence { protected int length=0; public int getLength()
Classes abstraites
65
{ return length; } public abstract void append(Object object); // ajoute l’objet donné à la fin de la séquence public int count(Object object) { int c=0; for (int i=0; i= longueur (length); public abstract boolean remove(Object object); // supprime la première occurrence de l’objet; // renvoie thrue si l’opération est réussie; public abstract Object set(int index, Object object); // renvoie l’objet à l’index donné après l’avoir remplacé par // l’objet donné, ou null l’opération est réussie public String toString() { if (length==0) return "()"; String s = "(" + get(0); for (int i=1; i
Cette classe contient cinq méthodes abstraites et quatre méthodes concrètes, c’est-à-dire non abstraites. Elle comporte également un champ. Remarquez que chaque déclaration de méthode abstraite se termine par un point-virgule. Le fait de définir une classe abstraite vous permet d’avoir recours à différentes implémentations de certaines méthodes qui sont terminées dans les sous-classes.
Exemple 3.9 Sous-classe ArraySequence de la classe Sequence public class ArraySequence extends Sequence { protected Object[] a; protected int capacity=16; // INVARIANT : a[i] != null pour 0 <= i < length; public ArraySequence()
66
Java avancé
{ a = new Object[capacity]; } public void append(Object object) { if (length==capacity) // doubler la capacité { Object[] tmp = a; capacity *= 2; a = new Object[capacity]; for (int i=0; i= length) return null; return a[index]; } public Object remove(int index) { if (index >= length) return null; Object x = a[index]; for (int i=index; i= length) return null; Object x = a[index]; a[index] = object; return x; } }
Cette sous-classe implémente la structure de la séquence comme s’il s’agissait d’un tableau d’Objects. Elle fournit un constructeur par défaut et implémente les cinq méthodes abstraites de la classe Sequence. En voici le pilote test : public class Ex0309 { public static void main(String[] args) { ArraySequence s = new ArraySequence(); System.out.println("s = " + s); s.append("Chili"); s.append("Chine"); s.append("Congo"); s.append("Egypte"); s.append("Chine"); s.append("Inde"); s.append("Italie"); s.append("Chine");
Interfaces
67
System.out.println("s = " + s); System.out.println("s.getLength() = " + s.getLength()); System.out.println("s.count(\"Chine\") = " + s.count("Chine")); System.out.println("s.get(5) = " + s.get(5)); System.out.println("s.indexOf(\"Chine\") = " + s.indexOf("Chine")); System.out.println("s.remove(5) = " + s.remove(5)); System.out.println("s.remove(\"Chine\") = " + s.remove("Chine")); System.out.println("s.indexOf(\"Chine\") = " + s.indexOf("Chine")); System.out.println("s.set(2,\"Japon\") = " + s.set(2,"Japon")); System.out.println("s = " + s); System.out.println("s.getLength() = " + s.getLength()); } } s = () s = (Chili,Chine,Congo,Egypte,Chine,Inde,Italie,Chine) s.getLength() = 8 s.count("Chine") = 3 s.get(5) = Inde s.indexOf("Chine") = 1 s.remove(5) = Inde s.remove("Chine") = true s.indexOf("Chine") = 3 s.set(2,"Japon") = Egypte s = (Chili,Congo,Japon,Chine,Italie,Chine) s.getLength() = 6
Cet exemple utilise un tabeau pour implémenter la classe Sequence définie dans l’exemple 3.8, mais d’autres implémentations sont possibles. Par exemple, nous aurions pu utiliser une structure chaînée similaire à celle de la classe Widget définie dans l’exemple 3.6. Vous pouvez choisir ultérieurement la méthode d’implémentation.
3.6 INTERFACES Un type de données abstrait est une description du comportement du type de données sans détails sur son mode d’implémentation. Dans le cadre de Java, un type de données est une classe et un type de données abstrait est une interface. Une interface est similaire à une classe abstraite, sauf qu’elle n’a pas d’implémentations de méthodes, ni de champs qui ne soient pas final. Elle sert de projet ou de contrat ; tout objet de classe qui implémente une interface est capable de faire ce que l’interface spécifie via ses méthodes. Par conséquent, les autres méthodes peuvent déclarer leurs paramètres de façon à avoir des types d’interface, des types de classe et des types primitifs. Le compilateur autorise le passage d’un objet à ce genre de paramètre tant qu’il s’agit d’une classe qui implémente l’interface, même dans le cas d’une classe abstraite.
Exemple 3.10 Interface Sequence Le programme suivant illustre le cas d’une interface qui pourrait être utilisée à la place de la classe abstraite définie dans l’exemple 3.8 : public interface Sequential { public abstract void append(Object object); // ajoute l’objet donné à la fin de la séquence public int count(Object object); // renvoie le nombre d’occurrences de l’objet // donné dans la séquence
68
Java avancé
public abstract Object get(int index); // renvoie l’objet à l’index donné, // ou null s’il n’est pas dans la séquence public int getLength(); // renvoie le nombre d’éléments de la séquence public int indexOf(Object object); // renvoie le nombre d’éléments précédant // la première occurrence de l’objet donné dans la séquence, // ou -1 si l’objet donné n’est pas dans la séquence public abstract Object remove(int index); // supprime et renvoie l’objet à l’index donné, // ou renvoie null si l’index >= longueur (length); public abstract boolean remove(Object object); // supprime la première occurrence de l’objet; // renvoie thrue si l’opération est réussie; public abstract Object set(int index, Object object); // renvoie l’objet à l’index donné après l’avoir remplacé par // l’objet donné, ou null si l’opération échoue public String toString(); // renvoie une chaîne qui affiche le contenu de la séquence }
Remarquez que les interfaces ne contiennent pas de code exécutable. Par définition, elles ne peuvent contenir que des déclarations de méthodes et des définitions de constantes. Remarquez également que, à l’instar de la bibliothèque Java standard, nous utilisons des formes nominatives pour les noms de classes et des adjectifs pour ceux des interfaces. Il est ainsi plus aisé de se rappeler qu’une classe est un type, tandis qu’une interface est une description de comportement. Par exemple, l’interface Sequential spécifie comment les instances de types qui l’implémentent doivent se comporter, c’est-à-dire comme des structures de données séquentielles. Les interfaces peuvent être utilisées comme les classes pour déclarer des variables et des paramètres, de la façon suivante : public static void print(Sequential sequence) { for (int i=0; i<sequence.getLength(); i++) System.out.println(i + ": " + sequence.get(i)); }
Ce code est compilé et aucune implémentation de l’interface Sequential n’est nécessaire. Cependant, pour être utile, une interface doit être implémentée. Pour cela, il suffit de définir une classe comprenant la définition de toutes les déclarations de méthodes spécifiées dans l’interface et d’ajouter la clause implements à la déclaration de classe.
Exemple 3.11 Implémenter l’interface Sequential à l’aide de la classe ArraySequence public class ArraySequence implements Sequential { protected int length=0; protected Object[] a; protected int capacity=16; // INVARIANT : a[i] != null pour 0 <= i < length; public ArraySequence() { a = new Object[capacity]; }
Interfaces
public void append(Object object) { if (length==capacity) // doubler la capacité { Object[] tmp = a; capacity *= 2; a = new Object[capacity]; for (int i=0; i= length) return null; return a[index]; } public int getLength() { return length; } public int indexOf(Object object) { for (int i=0; i= length) return null; Object x = a[index]; for (int i=index; i= length) return null; Object x = a[index]; a[index] = object; return x; } public String toString() { if (length==0) return "()"; String s = "(" + get(0); for (int i=1; i
69
70
Java avancé
Remarquez que l’exemple 3.11 utilise le même code que celui des exemples 3.8 et 3.9. Cela vous permet de constater que la classe abstraite et l’interface se différencient essentiellement par l’emplacement du code : dans une interface, tout le code exécutable doit se trouver dans l’implémentation, tandis que la classe abstraite peut avoir une partie du code exécutable dans l’implémentation et le reste dans la sous-classe. Les interfaces sont moins souples que les classes abstraites parce qu’elles ne peuvent pas inclure de code exécutable, mais elles sont également plus souples qu’elles car plusieurs interfaces peuvent être implémentées par une seule classe. Java ne permet pas l’héritage multiple, c’est-à-dire une classe qui étend plusieurs autres classes.
3.7 PAQUETAGES Un paquetage est une collection de classes et d’interfaces. Chaque nom de classe ou d’interface doit être unique dans un paquetage, mais le même nom peut être utilisé pour différentes classes ou interfaces de paquetages différents. Par exemple, il existe deux classes Object dans la bibliothèque standard Java : la première se trouve dans le paquetage java.lang et l’autre dans java.org.omg.CORBA. D’un point de vue technique, ces deux noms sont différents parce qu’ils s’écrivent ainsi lorsqu’ils sont complets : java.lang.Object et java.org.omg.CORBA.Object. En d’autres termes, le nom du paquetage auquel la classe appartient est en fait le préfixe du nom de la classe. Les paquetages sont organisés en hiérarchies arborescentes, exactement java applet comme les classes, les interfaces et les répertoires de fichiers (dossiers). awt En fait, les programmeurs Java mappent généralement chaque paquetage color dans un répertoire unique avec la hiérarchie de paquetage correspondant à event celle du répertoire. Ainsi, par exemple, tous les fichiers de classe du paqueimage tage java.awt.event seraient stockés dans le répertoire java/awt/ renderable event/ (ou dossier java\awt\event\ sous Windows). La hiérarchie beans de certains sous-paquetages Java est illustrée dans l’arbre ci-contre. beancontext io La plupart des environnements de développement Java (reportez-vous lang à l’annexe C) conseillent l’utilisation des paquetages. Ils mappent les ref champs du nom de paquetage au chemin du sous-répertoire vers le réperreflect toire dans lequel le paquetage est stocké. Par exemple, un paquetage math appelé books.schaums.dswj.util aurait un chemin d’accès Winutil dows appelé books\schaums\dswj\util.java. jar zip
3.8 GÉRER LES EXCEPTIONS Lorsque vous développez vos programmes, n’oubliez pas que le moindre détail peut être source d’erreur. Une exception est une erreur d’exécution qui provoque le transfert de l’exécution du programme de la source de la condition vers un gestionnaire d’exceptions. La source de la condition est qualifiée de lanceur d’exception et le gestionnaire d’attrapeur. Les erreurs d’exécution sont généralement encapsulées sous forme d’instances de la classe Throwable et de ses sous-classes. Les deux sous-classes qui en dérivent immédiatement sont les classes Error et Exception. La hiérarchie d’héritage suivante illustre en détail la classification des exceptions en fonction des conditions qui les provoquent.
Object Throwable Error LinkageError ThreadDeath VirtualMachineError Exception ClassNotFoundException IOException EOFException FileNotFoundException NoSuchFieldException NoSuchMethodException RuntimeException ArithmeticException IllegalArgumentException IndexOutOfBoundsException NullPointerException
Gérer les exceptions
71
Les deux exemples suivants vous indiquent deux méthodes de gestion d’une exception : en l’attrapant à l’aide de l’instruction try..catch, ou en la passant à l’appelant de l’environnement courant grâce à l’insertion de la clause throw dans la méthode courante.
Exemple 3.12 Une exception attrapée public class Ex0312 { public static void main(String[] args) { try { int n = Integer.parseInt("Abacadabra !"); System.out.println("n = " + n); } catch (Exception e) { System.out.println("e = " + e); } } } e = java.lang.NumberFormatException: Abacadabra !
L’appel Integer.parseInt("Abacadabra!") échoue parce que la chaîne passée ne représente pas un entier. La méthode lance un objet NumberFormatException qui est attrapé par la méthode main(). Les instructions exécutables du bloc catch sont exécutées lorsque l’exception est attrapée.
Exemple 3.13 Une exception non attrapée public class Ex0313 { public static void main(String[] args) { System.out.println("Essayez ça..."); int n = Integer.parseInt("Abacadabra !"); System.out.println("n = " + n); } } Essayez ça... Exception in thread "main" java.lang.NumberFormatException: Abacadabra ! at java.lang.Integer.parseInt(Integer.java:409) at java.lang.Integer.parseInt(Integer.java:458) at Testing.main(Testing.java:12)
Ce programme essaie d’effectuer le même appel de méthode que celui de l’exemple 3.12, mais hors d’un bloc try. C’est la raison pour laquelle le programmeur perd tout contrôle de l’exécution une fois l’exception lancée. En d’autres termes, le système plante et imprime un message d’erreur. La classe NumberFormatException est un descendant de la classe RuntimeException. Seules les extensions de cette dernière peuvent être gérées aisément, comme c’est le cas dans l’exemple 3.13. Toutes les autres exceptions (ou tout au moins la plupart d’entre elles) doivent être attrapées par la méthode à l’origine de l’erreur ou bien par une méthode déjà appelée sur la pile appelante. Les exceptions qui doivent être attrapées (c’est-à-dire qui ne sont pas des extensions de la classe RuntimeException) sont qualifiées d’exceptions vérifiées.
72
Java avancé
?
QUESTIONS DE RÉVISION
QUESTIONS DE RÉVISION
3.1
Qu’est-ce que l’héritage ?
3.2
Qu’est-ce que le polymorphisme ?
3.3
Qu’est-ce que le transtypage ?
3.4
Qu’est-ce que la promotion ?
3.5
Pourquoi la classe Object est-elle qualifiée de « mère de toutes les classes » en Java ?
3.6
Qu’est-ce qu’une méthode abstract ?
3.7
Qu’est-ce qu’une classe abstract ?
3.8
Quelle est la différence entre une classe abstract et une interface ?
3.9
Quelle est la différence entre une sous-classe et une extension de classe ?
3.10 Quelle est la différence entre une classe abstract et une classe concrète ? 3.11 Quelle est la différence entre une classe qui étend une autre classe et une classe qui implémente
une interface ? 3.12 Qu’est-ce qu’un bloc try ? 3.13 Quelle est la différence entre une exception vérifiée et une exception non vérifiée ?
¿
RÉPONSES
RÉPONSES
3.1
L’héritage décrit les relations entre une classe et une autre classe qui l’étend. Cette extension consiste à ajouter des champs et/ou des méthodes supplémentaires, voire d’autres méthodes qui remplacent celles définies dans la première classe. Cette dernière est appelée classe parent ou superclasse et la classe qui en est dérivée est appelée classe enfant ou sous-classe.
3.2
Le polymorphisme fait référence à un objet qui semble se comporter comme un autre. Cet objet similaire est en fait le même objet qui est considéré comme un membre de sa classe parent ou ancêtre.
3.3
Le transtypage correspond à l’utilisation de la valeur d’un type comme s’il s’agissait d’un autre type. Les objets ne peuvent pas modifier leurs types, mais leurs valeurs peuvent être affectées à des objets d’un autre type tant que deux types se trouvent sur le même chemin racine-vers-feuille dans l’arbre d’héritage. Par exemple : • String string1 = "ABCDE"; • Object object = (Object)string1; • • String string2 = (String)object; •
3.4
// // // //
transtypage d’une chaîne comme objet transtypage d’un objet comme chaîne
La promotion est le transtypage appliqué aux types primitifs. Les valeurs des types numériques peuvent être attribuées aux variables de type numérique supérieur. Par exemple : • int n = 44; // promotion d’un int en float • float x = n; // promotion d’un float en double • double y = x;
Révision et entraînement
73
3.5
Dans le cadre du langage Java, la classe Object est la seule sans classe parent. Elle se trouve à la racine de l’arbre d’héritage.
3.6
Une méthode abstract est simplement la déclaration de la fonction, c’est-à-dire les modificateurs, le type de renvoi et la signature de la méthode
3.7
Une classe abstract a au moins une méthode abstract.
3.8
Une classe abstract fonctionne comme une interface, mais elle peut en outre avoir des définitions de champs et des méthodes implémentées. Les méthodes d’une classe abstract qui ne sont pas implémentées doivent être déclarées à l’aide du mot-clé abstract. En revanche, une interface est une classe sans implémentation, c’est-à-dire qu’elle contient uniquement un listing des signatures de méthodes, sans instructions exécutables ni définitions de champs.
3.9
Il n’y a pas de différence entre une sous-classe et une extension de classe, ces deux expressions sont synonymes.
3.10 Une classe abstract est composée d’au moins une méthode abstract (c’est-à-dire implé-
mentée) alors que toutes les méthodes d’une classe concrète doivent être implémentées. 3.11 Lorsqu’une classe en étend une autre, elle hérite des méthodes de champs de cette dernière, à
l’exception des méthodes qu’elle remplace. Lorsqu’une classe implémente une interface, elle doit définir toutes les méthodes dont les signatures sont spécifiées dans l’interface. 3.12 Le bloc try est le bloc d’instructions qui suit le mot-clé try d’une instruction try..catch.
C’est à cet endroit que les méthodes qui lancent les exceptions vérifiées doivent être appelées à moins que la méthode appelante ne lance elle-même l’exception plus haut dans l’arbre appelant. 3.13 Une exception vérifiée est une exception qui doit être appelée par la méthode où elle a eu lieu ou
par une autre méthode située plus haut dans l’arbre appelant. Les méthodes qui lancent les exceptions vérifiées peuvent être appelées uniquement depuis les blocs try ou depuis d’autres méthodes lançant les exceptions. Les exceptions non vérifiées sont uniquement celles qui sont dérivées de la classe RuntimeException.
?
EXERCICES D’ENTRAÎNEMENT
EXERCICES D’ENTRAÎNEMENT
3.1
Étendez la classe Point (reportez-vous à l’exemple 1.7) afin de créer une classe Point3D en ajoutant une troisième coordonnée. Remplacez les méthodes suivantes : • public boolean equals(Object object); • public int hashCode(); • public String toString();
et ajoutez les méthodes suivantes : • private double z; • public Point3D(double x, double y); • public Point3D(double x, double y, double z); • public Point3D(Point3D q); • public double getZ(); • public void setLocation(double x, double y, double z); • public void translate(double dx, double dy, double dz);
74
Java avancé
3.2
Modifiez la classe Point3D de l’exercice précédent afin d’intégrer les ajouts effectués précédemment dans la classe Point. Remplacez les méthodes suivantes : • public double magnitude(); • public void expand(double dr);
et ajoutez les membres suivants : • public static final Point3D ORIGIN; • public Point3D(); • public double distance(Point3D point);
3.3
Essayez de deviner ce que le programme suivant imprimera. Exécutez-le afin de vérifier si vous aviez raison. • class X • { protected int a; • protected int b=22; • public X() • { System.out.print("X(): " + this); • System.out.print(" a = " + a + ", b = " + b); • a = 33; • b = 44; • System.out.println(" a = " + a + ", b = " + b); • } • public String toString() { return "Je suis un X."; } •} • class Y extends X • { protected int c=55; • public Y() • { System.out.print("Y(): " + this); • System.out.print(" a = " + a + ", b = " + b + ", c = " + c); • a = 66; • b = 77; • c = 88; • System.out.println(" a = " + a + ", b = " + b + ", c = " + c); • } • public String toString() { return "Je suis un Y."; } •} • public class Testing • { public static void main(String[] args) • { Y y = new Y(); • } •}
3.4 3.5
¿
Implémentez la méthode equals(Object) pour la classe Widget de l’exemple 3.6. Implémentez la méthode hashCode() pour la classe Widget de l’exemple 3.6.
SOLUTIONS
SOLUTIONS
3.1
Vous obtenez la classe Point3D suivante en étendant la classe Point : • public class Point3D extends Point • { protected double z; • public Point3D(double x, double y) • { this.x = x;
Révision et entraînement • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • •}
3.2
75
this.y = y; this.z = 0; } public Point3D(double x, double y, double z) { this.x = x; this.y = y; this.z = z; } public Point3D(Point3D q) { this.x = q.x; this.y = q.y; this.z = q.z; } public double getZ() { return z; } public void setLocation(double x, double y, double z) { this.x = x; this.y = y; this.z = z; } public void translate(double dx, double dy, double dz) { x += dx; y += dy; z += dz; } public boolean equals(Object object) { if (object == this) return true; if (object.getClass() != this.getClass()) return false; if (object.hashCode() != this.hashCode()) return false; Point3D point = (Point3D)object; return (x == point.x && y == point.y && z == point.z); } public int hashCode() { return (new Double(x)).hashCode() + (new Double(y)).hashCode() + (new Double(z)).hashCode(); } public String toString() { return new String("(" + (float)x + "," + (float)y + "," + (float)z + ")"); }
Vous ajoutez les membres à la classe Point3D de la façon suivante : • public static final Point3D ORIGIN = new Point3D(); • public Point3D() • { this.x = 0; • this.y = 0; • this.z = 0; •} • public double distance(Point3D point) • { double dx = this.x - point.x; • double dy = this.y - point.y; • double dz = this.z - point.z; • return Math.sqrt(dx*dx+dy*dy+dz*dz); •} • public double magnitude() • { return distance(ORIGIN); •}
76
Java avancé • public • { x *= • y *= • z *= •}
3.3
void expand(double dr) dr; dr; dr;
L’ordre des événements est le suivant : 1. Paramétrage des champs à l’aide des valeurs par défaut. 2. Appel du constructeur Y(). 3. Appel du constructeur X(). 4. Appel du constructeur Object. 5. Initialisation des champs X. 6. Exécution du constructeur X(). 7. Initialisation des champs Y. 8. Exécution du constructeur Y(). Vous obtenez alors la sortie suivante : • • X(): Je suis un Y. a = 0, b = 22 a = 33, b = 44 • Y(): Je suis un Y. a = 33, b = 44, c = 55 a = 66, b = 77, c = 88
3.4
La méthode equals(Object) est implémentée de la façon suivante pour la classe Widget : • public boolean equals(Object object) • { if (object == this) return true; • if (object.getClass() != this.getClass()) return false; • Widget y = (Widget)object; • Widget t = this; • while (y != null || t != null) • { if (y == null || t == null) return false; • if (y.n != t.n) return false; • y = y.w; • t = t.w; • } • return true; •}
3.5
La méthode hashCode() est implémentée de la façon suivante pour la classe Widget : • public int hashCode() • { int hc = (new Integer(n)).hashCode(); • Widget tw = this.w; • while (tw != null) • { hc += (new Integer(tw.n)).hashCode(); • tw = tw.w; • } • return hc; •}
Chapitre 4
Récursivité Une fonction est dite récursive lorsqu’elle s’appelle elle-même. Cette puissante technique de programmation crée des répétitions sans utiliser de boucles while, do..while ou for. C’est pourquoi elle est capable de produire des résultats substantiels à partir de très peu de code. En outre, la récursivité vous permettra de trouver des solutions d’une grande élégance à un certain nombre de problèmes. Attention cependant, lorsqu’elle est mal utilisée, cette subtilité informatique peut créer un code totalement inefficace. Le code récursif provient généralement des algorithmes récursifs.
Exemple 4.1 Fonction factorielle La fonction factorielle est définie mathématiquement de la façon suivante : n! = 1, if n = 0 n ( n – 1 )!, if n > 0
Cette définition est récursive parce que la factorielle revient à droite de l’équation. La fonction est définie par elle-même. Le tableau ci-contre contient les dix premières valeurs de la fonction factorielle. La première, 0! est définie par la moitié supérieure de la définition 0! = 1 (pour n = 0). Toutes les autres valeurs sont définies par la moitié inférieure de la définition, c’est-à-dire : • Pour n = 1, 1! = n! = n(n – 1)! = 1(1 – 1)! = 1(0)! = 1(1) = 1. • Pour n = 2, 2! = n! = n(n – 1)! = 2(2 – 1)! = 2(1)! = 2(1) = 2. • Pour n = 3, 3! = n! = n(n – 1)! = 3(3 – 1)! = 3(2)! = 3(2) = 6. • Pour n = 4, 4! = n! = n(n – 1)! = 4(4 – 1)! = 4(3)! = 4(6) = 24. • Pour n = 5, 5! = n! = n(n – 1)! = 5(5 – 1)! = 5(4)! = 5(24) = 120.
n
n!
0
1
1
1
2
2
3
6
4
24
5
120
6
720
7
5 040
8
40 310
9 362 880
Comme vous pouvez le constater, cette fonction croît rapidement.
Exemple 4.2 Implémenter récursivement la fonction factorielle Lorsqu’une fonction est définie récursivement, son implémentation est généralement une traduction directe de sa définition récursive. Les deux parties qui constituent la définition récursive de la fonction factorielle sont directement traduites en deux instructions Java : public static int f(int n) { if (n==0) return 1; // base return n*f(n-1); // partie récursive }
78
Récursivité
Vous trouverez ci-après un pilote test simple pour la fonction factorielle : public static void main(String[] args) { for (int n=0; n<10; n++) System.out.println("f("+n+") = "+f(n)); }
Ce programme est censé imprimer les mêmes valeurs que celles du tableau précédent.
Exemple 4.3 Implémenter itérativement la fonction factorielle Il est également facile d’implémenter la fonction factorielle itérativement : public static int f(int n) { int f=1; for (int i=2; i<=n; i++) f *= i; return f; }
Remarquez que l’en-tête de la fonction est identique à celui de l’exemple 4.2, seul le corps diffère. Cela nous permet d’utiliser le même pilote test pour les deux implémentations. Le résultat obtenu doit être identique dans les deux cas.
4.1 LA BASE ET LA PARTIE RÉCURSIVE DE LA RÉCURSIVITÉ Pour fonctionner correctement, chaque fonction récursive doit être composée d’une base et d’une partie récursive. La base arrête la récursivité et c’est dans la partie récursive que la fonction s’appelle elle-même.
Exemple 4.4 Base et partie récursive de la fonction factorielle Dans la méthode Java qui implémente la fonction factorielle de l’exemple 4.2, la base et la partie récursive sont associées à des commentaires. La partie récursive appelle la méthode et passe une valeur plus petite de n. Ainsi, si vous commencez par la valeur positive 5, les valeurs des appels suivants seront 4, 3, 2, 1 et 0. Lorsque 0 est passé, la base est exécutée, ce qui met un terme à la récursivité et provoque le début de la chaîne des renvois, soit 1, 1, 2, 6, 24 et 120. n Fn
Exemple 4.5 Nombres de Fibonacci Les nombres de Fibonacci sont les suivants : 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, …. Chaque nombre suivant le deuxième est la somme des deux nombres précédents. Il s’agit d’une définition récursive naturellement : 0, if n = 0 F n = 1, if n = 1 F n – 1 + F n – 2 , if n > 1
Les 15 premières valeurs de la séquence de Fibonacci sont présentées dans le tableau ci-contre. Les deux premières valeurs F0 et F1 sont définies par les deux premières parties de la définition : F0 = 0 (pour n= 0) et F1 = 1 (pour n = 1). Ces deux parties constituent la base de la récursivité.
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
79
Tracer un appel récursif
Toutes les autres valeurs sont définies par la partie récursive de la définition : • • • • • •
Pour n = 2, F2 = Fn = Fn – 1 + Fn – 2 = F(2) – 1 + F(2) – 2 = F1 + F0 = 1 + 0 = 1. Pour n = 3, F3 = Fn = Fn – 1 + Fn – 2 = F(3) – 1 + F(3) – 2 = F2 + F1 = 1 + 1 = 2. Pour n = 4, F4 = Fn = Fn – 1 + Fn – 2 = F(4) – 1 + F(4) – 2 = F3 + F2 = 2 + 1 = 3. Pour n = 5, F5 = Fn = Fn – 1 + Fn – 2 = F(5) – 1 + F(5) – 2 = F4 + F3 = 3 + 2 = 5. Pour n = 6, F6 = Fn = Fn – 1 + Fn – 2 = F(6) – 1 + F(6) – 2 = F5 + F4 = 5 + 3 = 8. Pour n = 7, F7 = Fn = Fn – 1 + Fn – 2 = F(7) – 1 + F(7) – 2 = F6 + F5 = 8 + 5 = 13.
Exemple 4.6 Implémenter récursivement la fonction Fibonacci public static int fib(int n) { if (n < 2) return n; // base return fib(n-1) + fib(n-2); // partie récursive }
Vous trouverez ci-après un pilote test simple de la méthode de Fibonacci : public static void main(String[] args) { for (int n=0; n<16; n++) System.out.println("fib(" + n + ") = " + fib(n)); }
Les valeurs obtenues devraient être identiques à celles du tableau de l’exemple 4.5.
4.2 TRACER UN APPEL RÉCURSIF Le traçage de l’exécution d’une méthode permet généralement de le rendre plus clair.
Exemple 4.7 Tracer la fonction factorielle récursive La figure suivante illustre comment vous pouvez tracer l’appel f(5) de la fonction factorielle récursive définie dans l’exemple 4.2 : main() n 5
f(5) 5 120
n 5
f(4) 4 24
n 4
f(3) 3
n 3
6
f(2) 2 2
n 2
f(1) 1
n 1
1
L’appel commence dans la fonction main() et la valeur 5 est passée à la fonction f(). La valeur du paramètre n est alors 5, f(4) est appelée et la valeur 4 est passée à la fonction f(). La valeur du paramètre n est alors 4, f(3) est appelée et la valeur 3 est passée à la fonction f(). Le processus continue (récursivement) jusqu’à ce que l’appel f(1) soit effectué depuis l’appel f(2). La valeur du paramètre n est alors 1. Cette valeur est renvoyée immédiatement sans qu’aucun autre appel ne soit effectué. L’appel f(2) renvoie ensuite 2*1=2 à l’appel f(3). L’appel f(3) renvoie à son tour 3*2=6 à l’appel f(4) qui renvoie 4*6=24 à l’appel f(5). En dernier lieu, l’appel f(5) renvoie la valeur 120 à main(). Le traçage de cet exemple indique que l’appel f(n) de l’implémentation récursive de la fonction factorielle générera n – 1 appels récursifs. Cette technique est clairement inefficace comparée à l’implémentation itérative de l’exemple 4.3.
Exemple 4.8 Tracer la fonction Fibonacci récursive La fonction Fibonacci (voir l’exemple 4.6) est plus récursive que la fonction factorielle de l’exemple 4.2 dans la mesure où elle inclut deux appels récursifs. Vous pouvez en constater les conséquences
80
Récursivité
dans la trace de l’appel fib(5) illustrée ci-après. L’appel commence dans la fonction main() et la valeur 5 est passée à la fonction fib(). La valeur du paramètre n est alors 5, fib(4) et fib(3) sont ensuite appelées et les valeurs 3 et 4 sont respectivement passées. Chacun de ces appels effectue ensuite deux appels récursifs jusqu’aux appels de base f(1) et f(0) qui renvoient tous les deux 1. Les appels récursifs renvoient ensuite la somme des deux valeurs qui leur ont été renvoyées pour que la valeur 8 soit finalement renvoyée à main(). main()
fib(5)
5
n 5
n 5
8
3
4 fib(4)
5
fib(3)
3
n 3
n 4 3
2
2
fib(3) 3
n 3 2 fib(2)
1 2
1
n 2 1 fib(1) n 1
2
fib(2)
fib(2)
n 2
n 2
1 fib(1)
fib(1)
n 1
n 1
0 1
1
fib(1)
n 0
n 1
2
1
fib(1) n 1
1 fib(0)
1
0 1
1
fib(0) n 0
0 1
1
fib(0) n 0
4.3 ALGORITHME RÉCURSIF DE RECHERCHE BINAIRE Nous avons déjà vu l’algorithme de recherche binaire non récursif dans la section 2.5. Vous vous rappelez certainement qu’il utilise la stratégie « Diviser pour mieux régner » en fractionnant la séquence en deux et en poursuivant l’analyse dans la moitié contenant l’élément recherché. Ce procédé est naturellement récursif.
Algorithme 4.1 Recherche binaire récursive (Condition préalable : s = {s0, s1, …, sn – 1} est une séquence triée de n valeurs ordinales du même type que x.) (Condition postérieure : l’index i est renvoyé lorsque si = x ; dans le cas contraire, –1 est renvoyé.) 1. Si la séquence est vide, renvoyer –1. 2. Supposons que si soit l’élément central de la séquence. 3. Si si = x, renvoyer son index i. 4. Si si < x, appliquer l’algorithme sur la sous-séquence se trouvant au-dessus de si. 5. Appliquer l’algorithme à la sous-séquence de ss se trouvant au-dessus de si. D’après la condition préalable de l’algorithme 4.1, la séquence doit être triée.
Exemple 4.9 Recherche binaire récursive public static int search(int[] a, int lo, int hi, int x) { // Condition préalable : a[0] <= a[1] <= ... <= a[a.length-1]; // Conditions postérieures : renvoie i; si i >= 0, alors a[i] == x; // sinon i == -1;
Algorithme récursif de recherche binaire
81
{if (lo>hi) return -1; // étape 1 int i = (lo+hi)/2; // étape 2 if (a[i] == x) return i; // étape 3 else if (a[i] < x) return search(a,i+1,hi,x); // étape 4 else return search(a,lo,i-1,x); // étape 5 } }
✽ Théorème 4.1 : la durée d’exécution de la recherche binaire récursive est égale à O(lgn). Démonstration : l’argument qui sous-tend ce théorème est globalement identique à celui du théorème 2.4. La durée d’exécution est proportionnelle au nombre d’appels récursifs effectués. Chaque appel traite une sous-séquence correspondant à la moitié de la précédente. C’est la raison pour laquelle le nombre d’appels récursifs est égal au nombre de fois où n peut être divisé par 2, soit lg n.
Exemple 4.10 Tester la recherche binaire récursive import schaums.dswj.Arrays; public class Ex0410 { private static final int SIZE = 16; private static final int START = 40; private static final int RANGE = 20; private static int[] a = new int[SIZE]; public static void main(String[] args) { Arrays.load(a,START,RANGE); java.util.Arrays.sort(a); Arrays.print(a); test(); test(); test(); test(); } public static void test() { int x = Arrays.load(START,RANGE); System.out.print("Recherche de x = " + x + ":\t"); int i = search(a,x); if (i >= 0) System.out.println("a[" + i + "] = " + a[i]); else System.out.println("i = " + i + " ==> x introuvable"); } public static int search(int[] a, int x) { return search(a,0,a.length-1,x); } public static int search(int[] a, int lo, int hi, int x) { if (lo>hi) return -1; // base int i = (lo+hi)/2; if (a[i] == x) return i; else if (a[i] < x) return search(a,i+1,hi,x); else return search(a,lo,i-1,x); } } 0 1 { 45, 45, Recherche Recherche Recherche Recherche
2 3 4 5 6 7 8 9 10 11 12 13 14 15 45, 45, 48, 48, 49, 50, 51, 52, 53, 54, 54, 58, 58, 59 } de x = 46: i = -1 ==> x introuvable de x = 48: a[5] = 48 de x = 54: a[11] = 54 de x = 57: i = -1 ==> x introuvable
82
Récursivité
Ce test est similaire à celui de l’exemple 2.8. Vous constaterez que, pour avoir la signature de méthode search(int[],int) avec uniquement deux paramètres, vous devez « envelopper » la méthode récursive dans une méthode pilote non récursive afin de la démarrer.
4.4 COEFFICIENTS BINOMIAUX Les coefficients binomiaux sont le résultat de l’expansion d’une expression binomiale de la forme (x + 1)n. Par exemple, (x + 1)6 =x6 + 6x5 + 15x4 = 20x3 + 15x2 + 6x +1 Les 7 coefficients générés ici sont 1, 6, 15, 20, 15, 6 et 1. Le mathématicien Pascal (1623-1662) a découvert une relation récursive dans les coefficients binomiaux. En les organisant dans un triangle, il a trouvé que chaque nombre interne est la somme des deux nombres se trouvant directement au-dessus de lui : 1 1 1 1 1
Ligne 6
1 1 1
8
4
6
6
15
1 1 4
10 20
35 56
Colonne 2
1 3
10
21 28
2
3
5
7
1
15 35
70
1 5
1 6
21 56
1 7
28
1 8
1
Par exemple, 15 = 5 + 10. Supposons que c(n,k) indique le coefficient du numéro de ligne n et du numéro de colonne k (en comptant à partir de 0). Si nous prenons l’exemple de c(6,2) = 15, la relation de récurrence de Pascal peut être exprimée de la façon suivante : c(n, k) = c(n–1, k–1) + c(n–1, k), for 0 < k < n soit, lorsque n = 6 et k = 2, c(6,2) = c(5,1) + c(5,2).
Exemple 4.11 Implémenter récursivement la fonction des coefficients binomiaux public static int c(int n, int k) { if (k==0 || k==n) return 1; // base return c(n-1,k-1) + c(n-1,k); // récursivité }
La base de la récursivité couvre les parties gauche et droite du triangle, avec k = 0 et k = n. Les coefficients binomiaux sont identiques aux nombres de combinaison utilisés en mathématiques combinatoires et calculés explicitement par la formule suivante : n n–1 n–2 n–k+1 n! c ( n, k ) = ----------------------- = --- ------------ ------------ … --------------------- 1 2 3 k k! ( n – k )!
Dans ce contexte, la combinaison est souvent écrite sous la forme suivante : c ( n, k ) = n k En outre, vous la lirez en disant que « n choisit k ». Par exemple, si n = 8 et k = 3, vous obtenez la combinaison suivante : 8 = ( 8 ⁄ 1 ) ( 7 ⁄ 2 ) ( 6 ⁄ 3 ) = 56 3
83
Algorithme d’Euclide
Exemple 4.12 Implémenter itérativement la fonction des coefficients binomiaux Cette version implémente la formule explicite donnée précédemment. L’expression de droite est composée de coefficients k, c’est pourquoi le calcul est effectué par une boucle répétée un nombre k de fois : public static int c(int n, int k) { if (n<2 || k==0 || k==n) return 1; int c=1; for (int j=1; j <= k; j++) c = c*(n-j+1)/j; return c; }
4.5 ALGORITHME D’EUCLIDE L’algorithme d’Euclide calcule le plus grand diviseur commun de deux entiers positifs. Il apparaît comme Proposition 2 du livre VII composant les Éléments d’Euclide (v. 300 av. J.-C.) et est probablement l’algorithme récursif le plus ancien. Tel qu’il a été initialement formulé par Euclide, il consiste à soustraire plusieurs fois le nombre n le plus petit du plus grand nombre m jusqu’à ce que la différence d obtenue soit plus petite que n. Répétez ensuite les mêmes étapes en remplaçant n par d et m par n. Continuez jusqu’à ce que les deux nombres soient égaux. Le nombre obtenu est alors le plus grand diviseur commun des deux nombres initiaux. Cet exemple applique l’algorithme d’Euclide pour rechercher le plus grand diviseur commun de 494 et 130, c’est-à-dire 26. Ceci est correct puisque 494 = 26⋅19 et 130 = 26⋅5.
494 –130 364 –130 234 –130 130 104 –104 26
104 –26 78 –26 52 –26 26
Exemple 4.13 Implémenter récursivement l’algorithme d’Euclide Chaque étape de cet algorithme ne fait que soustraire le plus petit nombre du plus grand en appelant récursivement gcd(m,n-n) ou gcd(m-n,n) : public static int gcd(int m, int n) { if (m==n) return n; // base else if (m
Par exemple, l’appel gcd(494,130) appelle récursivement gcd(364,130), qui appelle récursivement gcd(234,130), qui appelle récursivement gcd(104,130), qui appelle récursivement gcd(104,26), qui appelle récursivement gcd(78,26), qui appelle récursivement gcd(52,26), qui appelle récursivement gcd(26,26), qui renvoie 26. Cette valeur est ensuite renvoyée successivement jusqu’à l’appel initial gcd(494,130) qui la renvoie à sa routine d’appel.
4.6 PREUVE INDUCTIVE DE CORRECTION Les fonctions récursives sont généralement démontrées à l’aide du principe d’induction mathématique (voir l’annexe B). Selon ce principe, il est possible de prouver qu’une séquence infinie d’instructions est vraie en vérifiant (i) si la première instruction est vraie, et (ii) en en déduisant que toutes les autres propositions de la séquence sont vraies. L’étape (i) est qualifiée d’étape de base et (ii) d’étape inductive. La supposition selon laquelle les propositions précédentes sont vraies est qualifiée d’hypothèse inductive.
84
Récursivité
✽ Théorème 4.2 : la fonction factorielle récursive est correcte. Démonstration : pour prouver que l’implémentation récursive de la fonction factorielle est correcte (voir l’exemple 4.1), nous devons tout d’abord vérifier la base. L’appel f(0) renvoie la valeur correcte 1 en raison de la première ligne : if (n < 2) return 1;
Nous supposons ensuite que la fonction renvoie la valeur correcte pour tous les entiers inférieurs à un nombre n > 0. Puis la deuxième ligne : return n*f(n-1);
renverra la valeur n! correcte parce que, si nous nous en tenons à l’hypothèse inductive, l’appel f(n-1) renverra (n – 1)! et n! = n (n – 1). Remarquez que nous utilisons ici le principe fort d’induction mathématique (également qualifié de deuxième principe). Dans cette version, l’hypothèse inductive nous permet de supposer que toutes les propositions précédentes sont vraies. Dans le cadre du principe faible (ou premier principe), nous pouvons uniquement supposer que seule la proposition précédente est vraie. Cependant, étant donné que ces deux principes sont équivalents (c’est-à-dire qu’ils permettent tous les deux d’établir la preuve d’une proposition générale), il est généralement préférable d’appliquer la méthode d’induction forte. ✽ Théorème 4.3 : l’algorithme d’Euclide est correct. Démonstration : Pour prouver que l’algorithme d’Euclide (voir l’exemple 4.13) est correct, nous pouvons utiliser l’induction forte. Si m et n sont égaux, ce nombre est leur plus grand diviseur commun. La fonction renvoie donc la valeur correcte dans ce cas en raison de la ligne de code suivante : if (m == n) return n;
Si m et n ne sont pas égaux, la fonction renvoie gcd(m,n-m) ou gcd(m-n,n). Pour constater que cette valeur est également correcte, nous avons simplement besoin de voir que les trois paires (m,n), (m,n-m) et (m-n,n) auront toujours le même plus grand diviseur commun. Il s’agit là d’un théorème de la théorie des nombres présenté dans l’annexe B.
4.7 ANALYSE DE LA COMPLEXITÉ DES ALGORITHMES RÉCURSIFS L’analyse de la complexité d’un algorithme récursif dépend de sa relation de récurrence. Généralement, la meilleure technique consiste à utiliser T(n) comme nombre d’étapes nécessaires à l’application d’un algorithme pour un problème de taille n. La partie récursive de l’algorithme se traduit en relation de récurrence sur T(n). Sa solution est ensuite la fonction de complexité de l’algorithme. ✽ Théorème 4.4 : la fonction factorielle récursive a une durée d’exécution égale à O(n). Démonstration : supposons que T(n) soit le nombre d’appels récursifs effectués à partir de l’appel initial f(n) de la fonction (voir l’exemple 4.2). T(0) = T(1) = 0 parce que si n < 2, aucun appel récursif n’a lieu. Si n > 1, la ligne return n*f(n-1);
est exécutée et effectue l’appel récursif f(n - 1). Le nombre total d’appels récursifs est 1 plus le nombre d’appels effectués depuis f(n - 1), ce qui se traduit de la façon suivante dans la relation de récurrence : T(n) = 1 + T(n – 1) La solution de cette récurrence est la suivante : T(n) = n – 1, pour n > 0
85
Programmation dynamique
Nous arrivons à cette conclusion en deux étapes : tout d’abord, nous trouvons la solution, puis nous utilisons l’induction pour prouver qu’elle est correcte. La technique la plus simple de recherche d’une solution pour la relation de récurrence est de créer un tableau de valeurs et de rechercher un schéma. Dans le cas présent, la relation de récurrence nous indique que chaque valeur de T(n) est supérieure de 1 à la valeur précédente. La solution f(n) = n – 1 est donc plutôt évidente. Maintenant, pour prouver que T(n) = n – 1 chaque fois que n > 0, nous supposons que f(n) = n – 1 et nous appliquons le principe faible de l’induction mathématique. La situation de base est lorsque n = 1. Dans ce cas, T(n) = T(1) = 0 et f(n) = f(1) = (1) – 1 = 0. Pour l’étape inductive, nous supposons que T(n) = f(n) pour n > 0, puis nous en déduisons que T(n + 1) = f(n + 1) :
n
T (n)
0
0
1
0
2
1
3
2
4
3
5
4
6
5
T(n + 1) = 1 + T(n) = 1 + f(n) = 1 + (n – 1) = n f(n + 1) = (n + 1) – 1 = n Voilà qui termine notre démonstration. Maintenant que nous avons déterminé que la fonction de complexité pour l’implémentation récursive de la fonction factorielle T(n) = n – 1, nous pouvons en déduire que la durée d’exécution de cette implémentation sera proportionnelle à la taille de son argument n. S’il faut 3 millisecondes pour calculer 8!, il faudra environ 6 millisecondes pour calculer 16!.
4.8 PROGRAMMATION DYNAMIQUE Dans la plupart des cas, la récursivité est rendue inefficace par ses nombreux appels de fonctions. C’est la raison pour laquelle il est souvent préférable d’avoir recours à une implémentation itérative lorsqu’elle n’est pas trop complexe. Une troisième possibilité s’offre également à vous, elle consiste à implémenter la relation de récurrence en stockant les valeurs calculées précédemment dans un tableau au lieu de les recalculer grâce aux appels récursifs de fonctions. Cette méthode est qualifiée de programmation dynamique.
Exemple 4.14 Implémenter la fonction Fibonacci à l’aide de la programmation dynamique public static int fib(int n) { if (n<2) return n; int[] f = new int[n]; f[0] = 0; f[1] = 1; for (int i=2; i
Cette implémentation utilise un tableau dynamique f[] d’entiers longs n pour stocker les premiers nombres n de Fibonacci.
4.9 LES TOURS DE HANOI Nous venons de voir des exemples importants de fonctions qui sont définies plus naturellement et qui sont plus aisément compréhensibles si vous utilisez la récursivité. Dans certains cas, la récursivité est d’ailleurs la seule méthode acceptable, comme nous allons le voir pour le jeu des tours de Hanoi.
86
Récursivité
Ce jeu est composé d’un plateau sur lequel se trouA B C vent trois tours (appelées A, B et C) et une séquence de n disques avec un trou au centre. Les disques sont empilés par taille décroissante (c’est-à-dire d’abord le rayon de 8 cm, puis celui de 7 cm, 6 cm, 5 cm, etc.) sur la tour A. La règle est simple : aucun disque ne peut être placé sur un disque plus petit de la même tour. L’objectif est de déplacer tous les disques de la tour A vers la tour C, un disque à la fois, en respectant la règle énoncée précédemment. La solution générale est naturellement récursive : • Partie I : déplacer les disques n – 1 les plus petits de la tour A vers la tour B. • Partie II : déplacer le disque restant de la tour A vers la tour C. • Partie III : déplacer les disques n – 1 les plus petits de la tour B vers la tour C. Les étapes 1 et 3 sont récursives puisque vous appliquez la solution complète aux disques n – 1. La base de cette solution récursive est le cas n = 0, c’est-à-dire, ne faites rien. La solution du cas du disque n = 1 est la suivante : 1. Déplacer le disque de la tour A vers la tour C. La solution du cas des disques n = 2 est la suivante : 1. Déplacer le disque supérieur de la tour A vers la tour B. 2. Déplacer le deuxième disque de la tour A vers la tour C. 3. Déplacer le disque supérieur de la tour B vers la tour C. La solution du cas des disques n = 3 est la suivante : 1. 2. 3. 4. 5. 6. 7.
Déplacer le disque supérieur de la tour A vers la tour C. Déplacer le deuxième disque de la tour A vers la tour B. Déplacer le disque supérieur de la tour C vers la tour B. Déplacer le disque restant de la tour A vers la tour C. Déplacer le disque supérieur de la tour B vers la tour A. Déplacer le deuxième disque de la tour B vers la tour C. Déplacer le disque supérieur de la tour A vers la tour C.
Dans cet exemple, les étapes 1 à 3 constituent la première partie de la solution générale, l’étape 4 la deuxième partie et les étapes 5 à 7 la troisième partie. Étant donné que la solution générale récursive requiert la substitution de différents noms de tours, il est préférable d’utiliser des variables. Ainsi, si nous appelons cet algorithme en trois étapes hanoi(n,x,y,z), nous obtenons la solution suivante : • Partie I : déplacer les disques n –1 les plus petits de la tour x vers la tour z. • Partie II : déplacer le disque restant de la tour x vers la tour y. • Partie III : déplacer les disques n – 1 les plus petits de la tour z vers la tour y. Vous trouverez l’implémentation complète de cette solution générale dans l’exemple suivant.
Exemple 4.15 Les tours de Hanoi public class Ex0415 { public static void main(String[] args) { runHanoi(4,’A’,’B’,’C’); } public static void runHanoi(int n, char x, char y, char z) { if (n==1) // base
87
Récursivité mutuelle
System.out.println("Déplacer le disque supérieur de la tour " + x + " vers la tour " + z); else // récursivité { runHanoi(n-1,x,z,y); runHanoi(1,x,y,z); runHanoi(n-1,y,x,z); } } }
Dans le cas de quatre disques, la solution est créée par l’appel : runHanoi(4,’A’,’B’,’C’);
Vous obtenez alors la sortie suivante : Déplacer Déplacer Déplacer Déplacer Déplacer Déplacer Déplacer Déplacer Déplacer Déplacer Déplacer Déplacer Déplacer Déplacer Déplacer
le le le le le le le le le le le le le le le
disque disque disque disque disque disque disque disque disque disque disque disque disque disque disque
supérieur supérieur supérieur supérieur supérieur supérieur supérieur supérieur supérieur supérieur supérieur supérieur supérieur supérieur supérieur
de de de de de de de de de de de de de de de
la la la la la la la la la la la la la la la
tour tour tour tour tour tour tour tour tour tour tour tour tour tour tour
A A B A C C A A B B C B A A B
vers vers vers vers vers vers vers vers vers vers vers vers vers vers vers
la la la la la la la la la la la la la la la
tour tour tour tour tour tour tour tour tour tour tour tour tour tour tour
B C C B A B B C C A A C B C C
4.10 RÉCURSIVITÉ MUTUELLE Lorsqu’une fonction s’appelle elle-même, il s’agit d’une récursivité directe. Mais il existe aussi une récursivité indirecte, quand une fonction appelle d’autres fonctions, qui appellent d’autres fonctions, qui finissent par appeler la fonction initiale. La récursivité mutuelle est la forme la plus courante de ce type de récursivité ; elle a lieu lorsque deux fonctions s’appellent mutuellement.
g()
f() f() f()
g()
h()
Exemple 4.16 Fonctions sinus et cosinus calculées par récursivité mutuelle Les fonctions trigonométriques sinus et cosinus peuvent être définies de plusieurs façons et divers algorithmes vous permettent de calculer leurs valeurs. Bien qu’elle ne soit pas la plus efficace, la méthode la plus simple consiste à utiliser la récursivité mutuelle. Elle est basée sur les identités suivantes : sin2θ = 2sincosθ cos2θ = 1 – 2(sinθ)2 et sur les deux polynômes de Taylor : sinx ≈ x – x3/6 cosx ≈ 1 – x2/2 qui sont des approximations de petites valeurs de x.
88
Récursivité
public class Ex0416 { public static void main(String[] args) { for (double x=0. ; x<1.0; x += 0.1) System.out.println(s(x) + "\t" + Math.sin(x)); for (double x=0. ; x<1.0; x += 0.1) System.out.println(c(x) + "\t" + Math.cos(x)); } public static double s(double x) { if (-0.005 < x && x < 0.005) return x - x*x*x/6; // base return 2*s(x/2)*c(x/2); // récursivité } public static double c(double x) { if (-0.005 < x && x < 0.005) return 1.0 - x*x/2; // base return 1 - 2*s(x/2)*s(x/2); // récursivité } }
0.0 0.09983341664635367 0.1986693307941265 0.29552020665442036 0.3894183423068936 0.4794255385990945 0.5646424733830799 0.6442176872361944 0.7173560908968648 0.7833269096232099 0.8414709848016061 1.0 0.9950041652780733 0.9800665778414311 0.9553364891277464 0.9210609940036278 0.8775825618931635 0.8253356149178575 0.7648421872857489 0.6967067093499022 0.6216099682760496 0.5403023058779364
0.0 0.09983341664682815 0.19866933079506122 0.2955202066613396 0.3894183423086505 0.479425538604203 0.5646424733950354 0.644217687237691 0.7173560908995227 0.7833269096274833 0.8414709848078964 1.0 0.9950041652780258 0.9800665778412416 0.955336489125606 0.9210609940028851 0.8775825618903728 0.8253356149096783 0.7648421872844885 0.6967067093471655 0.6216099682706645 0.5403023058681398
Ce programme fonctionne parce que x est divisé par 2 à chaque appel récursif. Il finit ainsi par atteindre le critère de base (-0.005 < x && x < 0.005) qui arrête la récursivité. Lorsque x est très petit, les polynômes de Taylor donnent des résultats précis à 15 décimales près.
?
QUESTIONS DE RÉVISION
QUESTIONS DE RÉVISION
4.1 4.2
Une fonction récursive doit être composée d’une étape de base et d’une étape récursive. Expliquez en quoi consistent ces étapes et leur rôle essentiel dans la récursivité. Combien d’appels récursifs de la fonction factorielle récursive seront-ils générés par l’appel f(10) (voir l’exemple 4.2) ?
Révision et entraînement
89
4.3
Combien d’appels récursifs de la fonction récursive Fibonacci seront-ils générés par l’appel fib(6) (voir l’exemple 4.6) ?
4.4
Quels sont les avantages et les inconvénients de l’implémentation d’une solution récursive au lieu d’une solution itérative ?
4.5
Quelle est la différence entre la récursivité directe et la récursivité indirecte ?
¿
RÉPONSES
RÉPONSES
4.1
La base d’une fonction récursive est son point de départ lors de sa définition et son étape finale lorsqu’elle est appelée récursivement ; c’est ce qui termine la récursivité. Quant à la partie récursive, il s’agit de l’affectation qui comprend la fonction à droite de l’opérateur d’affectation et qui provoque l’appel de la fonction par elle-même ; c’est ce qui crée les répétitions. Par exemple, dans le cas de la fonction factorielle, la base est n! = 1 si n = 0 et la partie récursive est n! = n(n – 1) si n > 0.
4.2
L’appel factorial(10) générera 10 appels récursifs.
4.3
L’appel f(6) de la fonction Fibonacci générera 14 + 8 = 22 appels récursifs parce qu’il appelle f(5) et f(4) qui génèrent respectivement 14 et 8 appels récursifs.
4.4
Une solution récursive est souvent plus facile à comprendre que son équivalent itératif. Cependant, la récursivité s’exécute beaucoup plus lentement que l’itération.
4.5
La récursivité directe a lieu quand une fonction s’appelle elle-même. La récursivité indirecte a lieu lorsque des fonctions s’appellent entre elles.
?
EXERCICES D’ENTRAÎNEMENT
EXERCICES D’ENTRAÎNEMENT
4.1
Écrivez et testez une fonction récursive qui renvoie la somme des carrés des premiers entiers positifs n.
4.2
Écrivez et testez une fonction récursive qui renvoie la somme des premières puissances n d’une base b.
4.3
Écrivez et testez une fonction récursive qui renvoie la somme des premiers éléments n d’un tableau.
4.4
Écrivez et testez une fonction récursive qui renvoie le maximum des premiers éléments n d’un tableau.
4.5
Écrivez et testez une fonction récursive qui renvoie le maximum des premiers éléments n d’un tableau en n’utilisant pas plus de n lg appels récursifs.
4.6
Écrivez et testez une fonction récursive qui renvoie la puissance xn.
4.7
Écrivez et testez une fonction récursive qui renvoie la puissance xn, en n’utilisant pas plus de 2 n lg appels récursifs.
4.8
Écrivez et testez une fonction récursive qui renvoie le logarithme binaire entier d’un entier n (c’est-à-dire le nombre de fois où n peut être divisé par 2).
90 4.9
Récursivité
Écrivez et testez une fonction booléenne récursive qui détermine si une chaîne est un palindrome (c’est-à-dire une chaîne de caractères qui reste identique lorsque vous en inversez les lettres).
4.10 Écrivez et testez une fonction récursive qui renvoie une chaîne contenant la représentation
binaire d’un entier positif. 4.11 Écrivez et testez une fonction récursive qui renvoie une chaîne contenant la représentation hexa-
décimale d’un entier positif. 4.12 Écrivez et testez une fonction récursive qui imprime toutes les permutations des n premiers caractères d’une chaîne. Par exemple, l’appel print("ABC",3) imprimerait • ABC • ACB • BAC • BCA • CBA • CABr
4.13 Implémentez itérativement la fonction Fibonacci (sans utiliser de tableau). 4.14 Implémentez la fonction d’Ackermann récursive :
a(0, n) a(1, 0) a(m, 0) a(m, n)
=1 =2 = m + 2, if m >1 = a(a(m – 1, n), n – 1), if m > 0 et n > 0
4.15 Prouvez la relation de récurrence de Pascal. 4.16 Tracez l’implémentation récursive de l’algorithme d’Euclide (voir l’exemple 4.6) pour l’appel gcd(385,231). 4.17 Implémentez l’algorithme d’Euclide itérativement. 4.18 Implémentez l’algorithme d’Euclide récursivement en utilisant l’opérateur de reste entier % au
lieu de la soustraction répétée. 4.19 Implémentez l’algorithme d’Euclide itérativement en utilisant l’opérateur de reste entier % au
lieu de la soustraction répétée. 4.20 Utilisez l’induction mathématique pour prouver que l’implémentation récursive de la fonction
Fibonacci est correcte (voir l’exemple 4.6). 4.21 Utilisez l’induction mathématique pour prouver que la fonction récursive de l’exercice 4.4 est
correcte. 4.22 Utilisez l’induction mathématique pour prouver que la fonction récursive de l’exercice 4.5 est
correcte. 4.23 Utilisez l’induction mathématique pour prouver que la fonction récursive de l’exercice 4.8 est
correcte. 4.24 Utilisez l’induction mathématique pour prouver que la fonction récursive de l’exercice 4.12 est
correcte. 4.25 Le domaine calculable d’une fonction est l’ensemble des entrées pour lesquelles cette fonction
peut créer des résultats corrects. Déterminez empiriquement le domaine calculable de la fonction factorielle implémentée dans l’exemple 4.2. 4.26 Déterminez empiriquement le domaine calculable de la fonction sum(b,n) implémentée dans l’exercice 4.2 en utilisant b = 2.
91
Révision et entraînement
4.27 Déterminez empiriquement le domaine calculable de la fonction Fibonacci implémentée dans
l’exemple 4.3. 4.28 Déterminez empiriquement le domaine calculable de la fonction récursive des coefficients bino-
miaux de l’exemple 4.11. 4.29 Le programme des tours de Hanoi réalise 7 déplacements de disques pour 3 disques. Combien de
déplacements doivent être effectués si vous disposez de : a. 5 disques ? b. 6 disques ? c. n disques ? 4.30 Démontrez la formule dérivée de l’exercice précédent. 4.31 Déterminez empiriquement le domaine calculable de la fonction d’Ackermann de l’exer-
cice 4.14. 4.32 Créez l’arbre d’appels récursifs pour l’appel hanoi(4,'A', 'B', 'C') de l’exemple 4.15. 4.33 Modifiez le programme de l’exemple 4.16 afin d’obtenir des résultats plus précis en réduisant les
bases de façon à ce que la récursivité se poursuive jusqu’à ce que |x| < 0,00005. 4.34 Modifiez le programme de l’exemple 4.16 afin d’obtenir des résultats plus précis en utilisant des
approximations plus précises : sin x ≈ x – x3/6 + x5/120 = x(1 – x2(1 – x2/20)) cos x ≈ 1 – x2/2 + x4/24 = 1 – x2/2⋅(1 – x2/12) 4.35 Utilisez la récursivité mutuelle pour implémenter les fonctions de sinus et de cosinus hyperboli-
ques. Utilisez les formules suivantes : sinh 2θ = 2 sinh θ cosh θ cosh 2θ = 1 + 2 ( sinh θ )
2
3
sinh x ≈ x + x / 6 2
cosh x ≈ 1 + x / 2
Comparez vos résultats aux valeurs correspondantes des fonctions sinh et cosh définies en termes de fonction exponentielle par les formules suivantes : e x – e –x ) sinh x = (---------------------2
( ex
+e ) cosh x = ----------------------–x
2
4.36 Implémentez la fonction tangente récursivement en utilisant les formules suivantes :
2 tan x tan 2x = ---------------------------2 1 – ( tan x ) 1 3 tan x ≈ x + --- x 3 4.37 Implémentez une fonction récursive qui évalue un polynôme a0 +a1x + a2x2 +… + anxn, les coef-
ficients n + 1 ai étant passés à la fonction dans un tableau en même temps que le degré n.
92
Récursivité
¿
SOLUTIONS
SOLUTIONS
4.1
Cette fonction récursive renvoie la somme des premiers carrés n : • public static int sum(int n) • { if (n==0) return 0; // base • return sum(n-1) + n*n; // récursivité •}
4.2
Cette fonction récursive renvoie la somme des premières puissances n d’une base b : • public static double sum(double b, int n) • { if (n==0) return 1; // base • return 1 + b*sum(b,n-1); // récursivité •}
4.3
Remarquez que cette solution implémente la méthode de Horner : 1 + b*(1 + b*(1 + … + b)). Cette fonction récursive renvoie la somme des premiers éléments n d’un tableau : • public static double sum(double[] a, int n) • { if (n==0) return 0.0; // base • return sum(a,n-1) + a[n-1]; // récursivité •}
4.4
Cette fonction récursive renvoie le maximum des premiers éléments n d’un tableau : • public static double max(double[] a, int n) • { if (n==1) return a[0]; // base • double m = max(a,n-1); // récursivité • if (a[n-1] > m) return a[n-1]; • else return m; •}
4.5
Cette fonction récursive renvoie le maximum des premiers éléments n d’un tableau et n’effectue pas plus de n lg appels récursifs : • public static double max(double[] a, int lo, int hi) • { if (lo>=hi) return a[lo]; • int mid=(lo+hi)/2; // index central • double m1=max(a,lo,mid); // récursivité sur a[lo..mid] • double m2=max(a,mid+1,hi); // récursivité sur a[mid+1..hi] • return (m1>m2?m1:m2); // maximum de {m1,m2} •}
4.6
Cette fonction récursive renvoie la puissance xn : • public static double pow(double x, int n) • { if (n==0) return 1.0; // base • return x*pow(x,n-1); // récursivité •}
4.7
Cette fonction récursive renvoie la puissance xn et n’effectue pas plus de n lg appels récursifs : • public static double pow(double x, int n) • { if (n==0) return 1.0; // base • double p = pow(x,n/2); • if (n%2==0) return p*p; // récursivité (n pair) • else return x*p*p; // récursivité (n impair) •}
Révision et entraînement
4.8
Cette fonction récursive renvoie le logarithme binaire entier de n : • public static int lg(int n) • { if (n==1) return 0; // base • return 1 + lg(n/2); // récursivité •}
4.9
Cette fonction récursive détermine si une chaîne est un palindrome : • public static boolean isPalindrome(String s) • { int len = s.length(); • if (len<2) return true; • if (s.charAt(0) != s.charAt(len-1)) return false; • if (len==2) return true; • return isPalindrome(s.substring(1,len-1)); // récursivité •}
4.10 Cette fonction récursive convertit du décimal en binaire : • public static String binary(int n) • { String s; • if (n%2 == 0) s = "0"; • else s = "1"; • if (n < 2) return s; // base • return binary(n/2) + s; // récursivité •}
4.11 Cette fonction récursive convertit du décimal en hexadécimal : • public static String hexadecimal(int n) • { String s = hex(n%16); • if (n<16) return s; // base • return hexadecimal(n/16) + s; // récursivité •} • String hex(int n) • { if (n==0) return "0"; • if (n==1) return "1"; • if (n==2) return "2"; • if (n==3) return "3"; • if (n==4) return "4"; • if (n==5) return "5"; • if (n==6) return "6"; • if (n==7) return "7"; • if (n==8) return "8"; • if (n==9) return "9"; • if (n==10) return "A"; • if (n==11) return "B"; • if (n==12) return "C"; • if (n==13) return "D"; • if (n==14) return "E"; • else return "F"; •}
4.12 Cette fonction récursive imprime des permutations : • public static void print(String str) • { print("",str); •} • • public static void print(String left, String right) • { int n=right.length(); • if (n==0) return;
93
94
Récursivité • • • • • • • • • • • •}
if (n==1) { System.out.println(left+right); return; } StringBuffer s = new StringBuffer(right); for (int i=0; i
4.13 L’implémentation itérative de la fonction Fibonacci est la suivante : • public static int fib(int n) • { if (n<2) return n; • int f0=0, f1=1, f=f0+f1; • for (int i=2; i
4.14 Et voici la fonction d’Ackermann : • public static int ackermann(int m, int n) • { if (m==0) return 1; // base • if (n==0) • if (m==1) return 2; // base • else return m + 2; // base • return ackermann(ackermann(m-1,n), n-1); // récursivité •}
4.16 Considérez la relation c(8,3 = 56 = 35 + 21 = c(7,3) + c(7,2) issue de l’expansion de (x + 1)8 :
(x + 1)8 = (x + 1)(x + 1)7 = (x + 1)(x7 + 7x6 + 21x5 + 35x4 + 35x3 + 21x2 + 7x + 1) = x8 + 7x7 + 21x6 + 35x5 + 35x4 + 21x3 + 7x2 + x + x7 + 7x6 + 21x5 + 35x4 + 35x3 + 21x2 + 7x + 1 = x8 + 8x7 + 28x6 + 56x5 + 70x4 + 56x3 + 28x2 + 7x + 1 Le coefficient c(8,3) est pour le terme x5 qui est 35x5 +21x5 + 56x5. La somme 35x5 +21x5 est issue de x(35x4) et 1(21x5). Ces coefficients sont donc 35 = c(7,3) et 21 = c(7,2). La preuve générale est basée sur le même argument : c(n,k) est le coefficient du terme xk dans l’expansion de (x + 1)n. Étant donné que (x + 1)n = (x + 1)(x + 1)n – 1, ce terme vient de la somme (x)(c(n – 1, k – 1) xk – 1) + (1)(c(n – 1, k)xk) = (c(n – 1, k – 1) + c(n – 1, k)) xk Par conséquent, c(n, k) = c(n – 1, k – 1) + c(n – 1, k). 4.16 La trace de l’appel gcd(616,231) est la suivante : main()
gcd(385,231)
m 385 n 231
385,231 77
m 385 n 231
gcd(154,231)
154,231 77
m 154 n 231
gcd(154,77)
154,77 77
m 154 n 77
gcd(77,77)
77,77 77
m 77 n 77
Révision et entraînement
95
4.17 L’implémentation itérative de l’algorithme d’Euclide est la suivante : • public static int gcd(int m, int n) • { while (m != n) // INVARIANT : gcd(m,n) • if (m < n) n -= m; • else m -= n; • return n; •}
4.18 L’implémentation récursive de l’algorithme d’Euclide utilisant l’opérateur de reste est la sui-
vante : • public static int gcd(int m, int n) • { if (m==0) return n; // basis • if (n==0) return m; // basis • else if (m
4.19 L’implémentation itérative de l’algorithme d’Euclide utilisant l’opérateur de reste est la sui-
vante : • public static int gcd(int m, int n) • { while (n>0) // INVARIANT : gcd(m,n) • { int r = m%n; • m = n; • n = r; • } • return m; •}
4.20 Pour prouver que l’implémentation récursive de la fonction Fibonacci est correcte, vérifiez d’abord la base. Les appels fib(0) et fib(1) renvoient les valeurs correctes 0 et 1 en raison
de la première ligne • if (n < 2) return n;
Nous supposons ensuite que la fonction renvoie les valeurs correctes pour tous les entiers inférieurs à n > 1. La deuxième ligne • return fib(n-1) + fib(n-2);
renverra la valeur correcte n! parce que, si nous suivons l’hypothèse inductive, les appels fib(n-1) et fib(n-2) renvoient les valeurs correctes pour Fn – 1 et Fn – 2 respectivement, et Fn = Fn – 1 + Fn – 2 par définition. Remarquez que, dans le cas présent, la base requiert la vérification des deux premières étapes de la séquence parce que la relation de récurrence Fn = Fn – 1 + Fn – 2 s’applique uniquement pour n > 1. 4.21 Si n = 1, la base est exécutée et renvoie a[0] qui est l’élément maximum parce qu’il s’agit du
seul élément. Si n > 1, la fonction calcule correctement le maximum m des premiers éléments n–1 (selon l’hypothèse inductive). Si (a[m – 1] > m) est vraie, a[m – 1] est renvoyé. Cet élément est le plus grand puisqu’il est plus grand que le plus grand de tous les autres éléments. Dans le cas contraire, si la condition (a[n-1] >m) est fausse, m est renvoyé et il s’agit de l’élément le plus grand puisque a[m – 1] n’est pas plus grand. 4.22 Si n = 1, la base et exécutée et renvoie a[0] qui est l’élément maximum parce qu’il s’agit du seul élément. Si n > 1, la fonction calcule correctement les valeurs maximum m1 et m2 des première
et deuxième parties du tableau (selon l’hypothèse inductive). L’un de ces deux nombres est correct pour tout le tableau et le plus grand d’entre eux est renvoyé.
96
Récursivité
4.23 Si n = 1, la base est exécutée et renvoie 0 qui est le nombre de fois où n peut être divisé par 2. Si
n > 1, la fonction calcule correctement le nombre de fois où n/2 peut être divisé par 2 (selon l’hypothèse inductive). Ce nombre est inférieur de 1 au nombre de fois où n peut être divisé par 2. C’est pourquoi la valeur renvoyée, 1 + lg(n/2) est correcte. 4.24 Nous démontrons d’abord la conjecture selon laquelle l’appel print(left,right) imprimera n! chaînes distinctes ayant toutes le même préfixe left, avec n = right.length(). Si n = 1, la méthode imprime left+right et renvoie les données, soit 1! chaîne (distincte). Supposons que, lorsque right.length() = n – 1, l’appel print(left,right) imprime (n – 1)! Chaînes distinctes ayant toutes la chaîne de préfixe left. Ensuite, lorsque right.length() = n, la boucle for effectue n appels du type print(left+temp,ss), avec temp comme caractère distinct et ss = s.substring(1,n). Étant donné que la longueur de s.substring(1,n)
est égale à n – 1, chacun de ces appels imprime (n – 1)! chaînes distinctes ayant toutes la même chaîne de préfixe left+temp. C’est pourquoi la boucle imprime (n)(n – 1)! chaînes distinctes ayant toutes la même chaîne de préfixe left. Notre supposition est donc démontrée grâce à l’induction mathématique. Nous pouvons en déduire que l’appel print(str) imprimera n! permutations distinctes des caractères de la chaîne str, n étant sa longueur. Puisqu’il s’agit très exactement du nombre total de permutations de la chaîne, nous pouvons dire que la méthode est correcte. 4.25 En ce qui concerne la fonction factorielle implémentée dans l’exemple 4.2, le dépassement d’entier a lieu pour le type de renvoi long avec n = 13 sur l’ordinateur de l’auteur. C’est pour-
quoi le domaine calculable de cette fonction est 0 ≤ n ≤ 12. 4.26 En ce qui concerne la fonction sum(b,n) implémentée dans l’exercice 4.2 avec b = 2, le dépassement des nombres à virgule flottante a lieu pour le type de renvoi double avec n = 1,023 sur
l’ordinateur de l’auteur. Le domaine calculable de cette fonction est donc 0 ≤ n ≤ 1,022. 4.27 En ce qui concerne la fonction Fibonacci implémentée dans l’exemple 4.4, le temps système des
appels récursifs nuit considérablement aux performances d’exécution après n = 36 sur l’ordinateur de l’auteur. Le domaine calculable de cette fonction est donc environ 0 ≤ n ≤ 40. 4.28 En ce qui concerne la fonction des coefficients binomiaux de l’exemple 4.7, le temps système des
appels récursifs nuit considérablement aux performances d’exécution après n = 25 sur l’ordinateur de l’auteur. Le domaine calculable de cette fonction est donc environ 0 ≤ n ≤ 30. 4.29 Le programme des tours de Hanoi effectue :
a. 31 déplacements pour 5 disques ; b. 63 déplacements pour 6 disques ; c. 2n – 1 déplacements pour n disques. 4.30 Nous utiliserons l’induction mathématique pour démontrer que le programme des tours de Hanoi
effectue 2n – 1 déplacements de disques. La base est établie dans l’exemple 4.15. Pour déplacer n + 1 disques, vous devez effectuer 2n – 1 déplacements qui vous permettront de transférer tous les disques sauf le dernier dans la tour B (d’après l’hypothèse inductive). Vous aurez ensuite besoin d’effectuer un déplacement pour transférer le dernier disque dans la tour C et de 2n – 1 déplacements supplémentaires pour transférer les disques restants de la tour B à la tour C au-dessus du dernier disque dont nous venons de parler. Le total est donc de (2n – 1) + 1 + (2n – 1) = 2n + 1 – 1. 4.31 En ce qui concerne la fonction d’Ackermann de l’exercice 4.14, des exceptions sont lancées pour
m = 17 lorsque n = 2, pour m = 5 lorsque n = 3, pour m = 4 lorsque n = 4 et pour m = 3 lorsque n = 5. Le domaine calculable de cette fonction est donc limité à 0 ≤ m ≤ 16 lorsque n = 2, 0 ≤ m ≤ 4 lorsque n = 3, 0 ≤ m ≤ 3 lorsque n = 4 et à 0 ≤ m ≤ 2 lorsque n = 5.
97
Révision et entraînement
4.32 L’arbre d’appels de l’exemple 4.15 est le suivant :
h(2,A,B,C) h(3,A,C,B)
h(4,A,B,C)
h(1,A,C,B) h(1,A,B,C) h(1,B,A,C)
h(1,A,C,B) h(2,C,A,B)
h(1,C,B,A) h(1,C,A,B) h(1,A,C,B)
h(2,B,C,A)
h(1,B,A,C) h(1,B,C,A) h(1,C,B,A)
h(1,A,B,C)
h(3,B,A,C)
h(1,B,A,C) h(2,A,B,C)
h(1,A,C,B) h(1,A,B,C) h(1,B,A,C)
4.33 Voici un exemple d’implémentation récursive plus précise des fonctions sinus et cosinus : • public class Pr0433 • { public static void main(String[] args) • { for (double x=0. ; x<1.0; x += 0.1) • System.out.println(s(x) + "\t" + Math.sin(x)); • for (double x=0. ; x<1.0; x += 0.1) • System.out.println(c(x) + "\t" + Math.cos(x)); • } • public static double s(double x) • { if (Math.abs(x) < 0.00005) return x - x*x*x/6; • return 2*s(x/2)*c(x/2); • } • public static double c(double x) • { if (Math.abs(x) < 0.00005) return 1.0 - x*x/2; • return 1 - 2*s(x/2)*s(x/2); • } •}
4.34 Voici un autre exemple d’implémentation récursive plus précise des fonctions sinus et cosinus : • public class Pr0434 • { public static void main(String[] args) • { for (double x=0. ; x<1.0; x += 0.1) • System.out.println(s(x) + "\t" + Math.sin(x)); • for (double x=0. ; x<1.0; x += 0.1) • System.out.println(c(x) + "\t" + Math.cos(x)); • } • public static double s(double x) • { if (Math.abs(x) < 0.005) return x*(1 - x*x/6*(1-x*x/20)); • return 2*s(x/2)*c(x/2); • } • • public static double c(double x) • { if (Math.abs(x) < 0.005) return 1.0 - x*x/2*(1-x*x/12); • return 1 - 2*s(x/2)*s(x/2); • } •}
98
Récursivité
4.35 L’implémentation récursive mutuelle des fonctions sinus et cosinus hyperboliques est la suivante : • public class Pr0435 • { public static void main(String[] args) • { for (double x=0. ; x<1.0; x += 0.1) • System.out.println(s(x) + "\t" + sinh(x)); • for (double x=0. ; x<1.0; x += 0.1) • System.out.println(c(x) + "\t" + cosh(x)); • } • • public static double s(double x) • { if (Math.abs(x) < 0.005) return x + x*x*x/6; • return 2*s(x/2)*c(x/2); • } • • public static double c(double x) • { if (Math.abs(x) < 0.005) return 1.0 + x*x/2; • return 1 + 2*s(x/2)*s(x/2); • } • • public static double sinh(double x) • { return (Math.exp(x) - Math.exp(-x))/2.0; • } • • public static double cosh(double x) • { return (Math.exp(x) + Math.exp(-x))/2.0; • } •}
4.36 L’implémentation récursive de la fonction tangente est la suivante : • public static double t(double x) • { if (-0.005 < x && x < 0.005) return x + x*x*x/3; // base • return 2*t(x/2)/(1 - t(x/2)*t(x/2)); // récursivité •}
4.37 L’évaluation récursive d’une fonction polynomiale est la suivante : • public static double p(double[] a, double x) • { // renvoie a[0] + a[1]*x + a[2]*x*x + ... • return p(a,x,0); •} • • private static double p(double[] a, double x, int k) • { // renvoie a[k] + a[k+1]*x + a[k+2]*x*x + ... • if (k == a.length) return 0; // base • return a[k] + x*p(a,x,k+1); // récursivité •}
Chapitre 5
Collections Une collection est un conteneur d’objets. Java 1.2 a formalisé ce concept avec son framework de collections composées d’interfaces et de classes.
5.1 FRAMEWORK DE COLLECTIONS JAVA Le paquetage java.util définit le framework suivant composé de huit interfaces pour les collections : Interface
Description
Collection
Collection d’éléments.
List
Séquence d’éléments.
Set
Collection d’éléments uniques.
SortedSet
Collection triée d’éléments uniques.
Map
Collection de paires (clé, valeur) avec des clés obligatoirement uniques.
SortedMap
Collection triée de paires (clé, valeur) avec des clés obligatoirement uniques.
Iterator
Objet capable de parcourir une collection.
ListIterator
Objet capable de parcourir une séquence.
100
Collections
Le graphique suivant illustre les relations entre les interfaces et les classes qui les implémentent : Object AbstractCollection
Collection
AbstractList
List
AbstractSequentialList LinkedList ArrayList Vector Stack AbstractSet
Set
HashSet TreeSet AbstractMap
SortedSet Map
HashMap SortedMap
TreeMap WeakHashMap
Iterator
Arrays BitSet
ListIterator
Collections Dictionary Hashtable
Map
Properties
Les lignes en pointillés connectent les interfaces situées à droite du graphique aux classes de la partie gauche qui les implémentent directement. Par exemple, la classe Hashtable implémente l’interface Map. Dans les classes comme dans les interfaces, l’héritage est indiqué par des lignes continues. Par exemple, la classe Stack étend la classe Vector et l’interface SortedSet étend l’interface Set. Remarquez que chacune des quatre interfaces principales (Collection, List, Set et Map) est implémentée par une classe abstract correspondante (AbstractCollection, AbstractList, AbstractSet et AbstractMap). Remarquez également que le nom de la plupart des classes de collection concrètes est composé de la structure de données utilisée et de l’interface implémentée. Ainsi, la classe ArrayList utilise un tableau pour implémenter l’interface List, la classe HashSet utilise une table de hachage pour implémenter l’interface Set et la classe TreeMap utilise un arbre pour implémenter l’interface Map. Ce chapitre est consacré aux implémentations directes des interfaces Collection et Iterator. L’implémentation des six autres interfaces sera abordée dans les chapitres 7, 13 et 14.
5.2 INTERFACE Collection Comme vous avez pu le constater dans le graphique précédent, l’interface Collection définit le framework de toutes les classes conteneurs Java. Elle est définie de la façon suivante dans le paquetage java.util : public interface Collection { public boolean add(Object object); public boolean addAll(Collection collection); public void clear(); public boolean contains(Object object); public boolean containsAll(Collection collection); public boolean equals(Object object); public int hashCode();
101
Classe AbstractCollection
public public public public public public public public
boolean Iterator boolean boolean boolean int Object[] Object[]
isEmpty(); iterator(); remove(Object object); removeAll(Collection collection); retainAll(Collection collection); size(); toArray(); toArray(Object[] objects);
}
5.3 CLASSE AbstractCollection La classe AbstractCollection est une implémentation partielle de l’interface Collection. Elle implémente autant d’éléments que possible sans spécifier la structure de stockage utilisée par la collection. Elle est définie de la façon suivante dans le paquetage java.util : public class AbstractCollection implements Collection { public boolean add(Object object) public boolean addAll(Collection collection) public void clear() public boolean contains(Object object) public boolean containsAll(Collection collection) public boolean isEmpty() abstract public Iterator iterator() public boolean remove(Object object) public boolean removeAll(Collection collection) public boolean retainAll(Collection collection) abstract public int size() public Object[] toArray() public Object[] toArray(Object[] objects) public String toString() }
Notez que cette classe implémente les 15 méthodes spécifiées par l’interface Collection, à l’exception de equals() et hashCode() qui sont définies dans la classe Object (reportez-vous à la section 3.4) et qui seront remplacées par des extensions de la classe AbstractCollection. En outre, la classe AbstractCollection remplace la méthode toString() de la classe Object. Si AbstractCollection ne remplace pas les méthodes equals() et hashCode() de la classe Object, c’est parce que celles-ci ne peuvent pas être complètement définies si vous ignorez quelle structure de données implémentera le stockage des éléments du conteneur. En revanche, AbstractCollection est en mesure de remplacer la méthode toString() de la classe Object, comme illustré dans l’exemple suivant.
Exemple 5.1 Méthode toString() définie dans la classe AbstractCollection public String toString() { if (isEmpty()) return "[]"; Iterator it = iterator(); String str = "[" + it.next(); while (it.hasNext()) str += ", " + it.next(); return str + "]"; }
Cette méthode utilise l’itérateur renvoyé par la méthode iterator() de la classe afin de parcourir la collection et d’obtenir une image chaîne de tous ses éléments. Pour travailler sur l’instance d’une sous-classe concrète de la classe AbstractCollection, il suffit de se baser sur cette implémenta-
102
Collections
tion correcte de la méthode iterator(). C’est la raison pour laquelle AbstractCollection définit une méthode iterator() abstraite : de cette façon, elle sera toujours implémentée par une sous-classe concrète. La méthode size() de la classe AbstractCollection est définie comme étant abstraite pour la même raison. Cette classe est utilisée par d’autres méthodes implémentées dans le code que nous venons de voir (exemple 5.2).
Exemple 5.2 Méthode isEmpty() définie dans la classe AbstractCollection public boolean isEmpty() { return size() == 0; }
5.4 CLASSE Bag Un sac (bag), également qualifié de multi-ensemble, est une collection d’éléments susceptibles de contenir des copies. En effet, les ensembles standard n’autorisent pas les copies. Dans l’exemple suivant, vous verrez comment utiliser un tableau d’Objects pour implémenter une classe Bag.
Exemple 5.3 Classe Bag public class Bag extends AbstractCollection { private Object[] objects; private int size=0; // nombre d’objets dans le sac private static final int CAPACITY=16; // capacité par défaut private void resize(int capacity) // augmente la taille de objects[] jusqu’à une capacité donnée // reportez-vous à l’exemple 5.4 public Bag() { // construit un sac vide avec la capacité par défaut objects = new Object[CAPACITY]; } public Bag(int capacity) // construit un sac vide avec la capacité donnée // reportez-vous à l’exercice d’entraînement 5.1 public Bag(Collection collection) // construit un sac contenant les objets de // la collection donnée en doublant sa capacité // reportez-vous à l’exemple 5.5 public Bag(Object[] objects) // construit un sac contenant les objets du // tableau donné en doublant sa capacité // reportez-vous à l’exercice d’entraînement 5.2 public boolean add(Object object) // ajoute l’objet donné au sac // reportez-vous à l’exemple 5.6 public boolean addAll(Collection collection) // ajoute tous les objets de la collection donnée dans le sac // reportez-vous à l’exercice d’entraînement 5.3
Classe Bag
103
public void clear() // supprime tous les objets du sac // reportez-vous à l’exercice d’entraînement 5.4 public boolean contains(Object object) // renvoie true si l’objet donné // est égal à un objet du sac // reportez-vous à l’exemple 5.7 public boolean containsAll(Collection collection) // renvoie true si chaque objet de la collection donnée // est égal à un objet du sac, c’est-à-dire // si la collection donnée est un sous-ensemble du sac; // reportez-vous à l’exercice d’entraînement 5.5 private static int frequency(Collection x, Object object) // renvoie le nombre d’objets de la collection donnée // qui sont égaux à l’objet donné // reportez-vous à l’exercice d’entraînement 5.6 public boolean equals(Object object) // renvoie true si l’objet donné est un sac // et a le même contenu que le sac donné // reportez-vous à l’exemple 5.8 public int hashCode() // renvoie le code de hachage du sac, c’est-à-dire la somme // de tous les codes de hachage de ses éléments // reportez-vous à l’exercice d’entraînement 5.7 public boolean isEmpty() { // renvoie true si le sac est vide return size == 0; } public Iterator iterator() // renvoie un itérateur sur le sac // reportez-vous à l’example 5.12 public boolean remove(Object object) // supprime l’un des objets donnés du sac; // renvoie true si le sac a été modifié; // reportez-vous à l’exercice d’entraînement 5.8 public boolean removeAll(Object object) // supprime la totalité de l’objet donné du sac; // renvoie true si le sac a été modifié; // reportez-vous à l’exemple 5.9 public boolean removeAll(Collection collection) // supprime du sac tous les objets se trouvant également dans // la collection donnée, réduisant ainsi ce sac à son // intersection théorique avec cette collection; // renvoie true si le sac a été modifié; // reportez-vous à l’exercice d’entraînement 5.9 public boolean retainAll(Collection collection) // supprime du sac tous les objets ne se trouvant pas dans la // collection donnée, réduisant ainsi le sac au complément théorique // de cette collection;
104
Collections
// renvoie true si le sac a été modifié; // reportez-vous à l’exercice d’entraînement 5.10 public int size() { // renvoie le nombre d’objets contenus dans le sac; return size; } public Object[] toArray() // renvoie un tableau dont les éléments se trouvent dans le sac; // reportez-vous à l’exemple 5.10 public Object[] toArray(Object[] objects) // renvoie un tableau dont les éléments se trouvent dans le sac // s’il est plus grand que le tableau object[] donné; // sinon, le tableau donné est renvoyé après suppression // de tous ses éléments, puis il est chargé avec les éléments du sac // et null pour combler les vides; // reportez-vous à l’exercice d’entraînement 5.11 public String toString() // renvoie une chaîne avec le contenu du sac // reportez-vous à l’exercice d’entraînement 5.12 }
Exemple 5.4 Implémenter la méthode Bag.resize(int) Cette méthode utilitaire privée est intégrée afin de faciliter l’expansion du tableau objects[] lorsque de nouveaux éléments sont ajoutés au sac. private void resize(int capacity) { // augmente la taille du tableau objects[] jusqu’à la // capacité donnée if (capacity <= this.capacity) return; Object[] temp = objects; objects = new Object[capacity]; for (int i=0; i<size; i++) objects[i] = temp[i]; }
Si la capacity donnée n’est pas plus importante que la capacity courante, la méthode renvoie le tableau sans rien changer. Dans le cas contraire, elle copie tout le tableau objects dans un tableau temp, réaffecte la référence objects à un nouveau tableau de taille équivalente à la capacity donnée, tableau dans lequel elle copie le tableau temp.
Exemple 5.5 Implémenter un constructeur Bag(Collection) public Bag(Collection collection) { // construit un sac contenant les objets de // la collection donnée en doublant sa capacité objects = new Object[2*collection.size()]; for (Iterator it = collection.iterator(); it.hasNext(); ) objects[size++] = it.next(); }
Pour créer un Bag contenant les éléments de la collection donnée, cette méthode alloue d’abord le tableau objects avec le double des composants de cette collection (afin de permettre l’augmentation ultérieure du tableau).
Classe Bag
105
Elle utilise ensuite un itérateur pour parcourir la collection et copie chaque variable de référence de ses objets dans le nouveau tableau objects du sac. Notez que les objets qui composent la collection ne sont pas copiés dans notre exemple qui ne propose qu’une nouvelle structure de données de références à ces objets. Étant donné que la collection donnée implémente l’interface Collection, vous aurez nécessairement une méthode iterator() qui renverra un objet itérateur capable de parcourir cette collection. En outre, puisque cet objet itérateur implémente l’interface java.util.Iterator (reportezvous à la section 5.5), vous retrouverez nécessairement les méthodes next() et hasNext() utilisées dans notre exemple. Elles permettent l’utilisation d’une boucle for afin de parcourir la collection et d’accéder à chacun de ses éléments via la méthode next().
Exemple 5.6 Implémenter la méthode Bag.add(Object) public boolean add(Object object) { // ajoute l’objet donné au sac if (size == objects.length) resize(2*objects.length); objects[size++] = object; return true; }
Si le sac est plein, la méthode private resize() est appelée en premier lieu afin de doubler la capacité du tableau objects[]. L’objet donné est ensuite ajouté à la séquence d’éléments se trouvant déjà dans le tableau. Lorsque vous utilisez l’interface Collection, n’oubliez pas que la méthode add(Object) doit renvoyer une valeur boolean afin d’indiquer si l’opération d’ajout est réussie ou non. Avec cette implémentation, l’ajout sera toujours réussi (à moins que l’ordinateur ne se retrouve à cours de mémoire), c’est pourquoi true sera automatiquement renvoyé. Nous verrons dans d’autres applications que la méthode add(Object) peut parfois renvoyer false. Voici un pilote test de la méthode add(Object) : public class Testing { public static void main(String[] args) { String[] food = { "fromage", "jambon", "rhum", "thé" }; Bag foodBag = new Bag(food); System.out.println(foodBag); foodBag.add("figue"); System.out.println(foodBag); } } { fromage, jambon, rhum, thé } { fromage, jambon, rhum, thé, figue }
Notez que ce programme teste également le constructeur Bag(Object[]).
Exemple 5.7 Implémenter une méthode Bag.contains(Object) Cette méthode implémente l’algorithme de recherche séquentielle (reportez-vous à la section 2.4) afin de retrouver l’object donné dans le sac. Elle effectue une recherche dans le tableau objects[] et renvoie true dès que l’un de ses éléments est égal à l’object donné. Si la boucle se termine une fois que tous les éléments ont été vérifiés, la méthode renvoie false : public boolean contains(Object object) { // renvoie true si l’objet donné // est égal à un objet du sac
106
Collections
for (int i=0; i<size; i++) if (object.equals(objects[i])) return true; return false; }
Remarquez que cette méthode utilise la méthode Object.equals() afin de tester l’égalité. Cet appel renvoie true uniquement si les deux références object et objects[i] concernent toutes les deux le même objet. Voici le pilote test de la méthode contains(Object) : public class Testing { public static void main(String[] args) { String[] food = { "fromage", "jambon", "rhum", "thé" }; Bag foodBag = new Bag(food); System.out.println(foodBag); if (foodBag.contains("figue")) System.out.println("figue"); else System.out.println("pas de figue"); if (foodBag.contains("jambon")) System.out.println("jambon"); else System.out.println("pas de jambon"); } } { fromage, jambon, rhum, thé } pas de figue jambon
Notez que les deux occurrences du littéral chaîne doivent faire référence au même objet se trouvant en mémoire.
Exemple 5.8 Implémenter une méthode Bag.equals(Object) public boolean equals(Object object) { // renvoie true si l’objet donné est un sac // et a le même contenu que le sac donné if (object == this) return true; if (object.getClass() != this.getClass()) return false; if (object.hashCode() != this.hashCode()) return false; Collection collection = (Collection)object; if (collection.size() != this.size()) return false; if (!collection.containsAll(this)) return false; if (!this.containsAll(collection)) return false; for (int i=0; i<size; i++) { Object x = objects[i]; if (frequency(collection,x) != frequency(this,x)) return false; } return true; }
Exemple 5.9 Implémenter une méthode Bag.removeAll(Object) public boolean removeAll(Object object) { // supprime tous les objets donnés du sac; // renvoie true si le sac a été modifié; boolean modified=false; for (int i=0; i<size; i++) if (object.equals(objects[i])) { objects[i] = objects[--size];
Classe Bag
modified = true; } return modified; }
Exemple 5.10 Implémenter une méthode Bag.toArray() public Object[] toArray() { // renvoie un tableau dont les éléments sont dans le sac; Object[] objects = new Object[size]; for (int i=0; i<size; i++) objects[i] = this.objects[i]; return objects; }
Exemple 5.11 Tester la classe Bag Voici un pilote test de la classe Bag définie dans l’exemple 5.3 : public class Ex0511 { public static void main(String[] args) { String[] etats = { "Maine", "Idaho", "Iowa", "Ohio", "Utah" }; Bag myCollection = new Bag(etats); print(myCollection); myCollection.add("Alaska"); print(myCollection); if (myCollection.remove("Ohio")) print(myCollection); else System.out.println("Object \"Ohio\" introuvable."); Iterator it = myCollection.iterator(); while (it.hasNext()) { String s = (String)it.next(); System.out.println("\ts = \""+s+"\""); if (s.charAt(0) == ’I’) { it.remove(); System.out.println("\tObjet \""+s+"\" a été supprimé."); } } print(myCollection); } private static void print(Bag collection) { System.out.println("size() = " + collection.size()); Object[] objects = collection.toArray(); for (int i=0; i
107
108
Collections
else System.out.println("\tnewC n’est pas égal à myC"); } }
size() = 5 objects[0] = Maine objects[1] = Idaho objects[2] = Iowa objects[3] = Ohio objects[4] = Utah Contains "Iowa" newC contient myC myC contient newC myC est égal à newC newC est égal à myC size() = 6 objects[0] = Maine objects[1] = Idaho objects[2] = Iowa objects[3] = Ohio objects[4] = Utah objects[5] = Alaska Contient "Iowa" newC ne contient pas myC myC contient newC myC n’est pas égal à newC newC n’est pas égal à myC size() = 5 objects[0] = Maine objects[1] = Idaho objects[2] = Iowa objects[3] = Alaska objects[4] = Utah Contient "Iowa" newC ne contient pas myC myC ne contient pas newC myC n’est pas égal à newC newC n’est pas égal à myC s = "Maine" s = "Idaho" Objet "Idaho" supprimé. s = "Utah" s = "Iowa" Objet "Iowa" supprimé. s = "Alaska" size() = 3 objects[0] = Maine objects[1] = Utah objects[2] = Alaska Ne contient pas "Iowa" newC ne contient pas myC myC ne contient pas newC myC n’est pas égal à newC newC n’est pas égal à myC
Interface Iterator
109
5.5 INTERFACE Iterator Un itérateur est un objet qui parcourt une structure de données et en vérifie chaque élément une seule fois. Étant donné que le temps est linéaire, un itérateur linéarise la structure qu’il parcourt. Plusieurs itérateurs peuvent vérifier une structure simultanément, chacun d’entre eux étant en mesure d’identifier un élément de la structure et d’en permettre l’accès. Voici l’interface Iterator telle qu’elle est définie dans le paquetage java.util : public interface Iterator { public boolean hasNext(); public Object next(); public void remove(); }
Les itérateurs sont généralement implémentés comme des classes internes anonymes définies dans la méthode iterator() de la classe de collection associée, comme illustré dans l’exemple suivant.
Exemple 5.12 Implémenter la méthode Iterator dans la classe Bag Voici maintenant l’implémentation de la méthode iterator() pour la classe Bag définie dans l’exemple 5.3 : public Iterator iterator() { // renvoie un itérateur sur le sac return new Iterator() // définition du constructeur incorporée : { private int cursor=0; public boolean hasNext() { return cursor<size; } public Object next() { if (cursor>=size) return null; return objects[cursor++]; } public void remove() { objects[--cursor] = objects[--size]; objects[size] = null; } }; // notez le point-virgule obligatoire }
?
QUESTIONS DE RÉVISION
QUESTIONS DE RÉVISION
5.1 5.2 5.3
Qu’est-ce que le framework de collections Java ? Pourquoi les méthodes iterator() et size() sont-elles déclarées comme abstract dans la définition de la classe AbstractCollection ? Qu’est-ce qu’un itérateur ?
110
Collections
¿
RÉPONSES
RÉPONSES
5.1 5.2
5.3
?
Le framework de collections Java est un groupe d’interfaces et de classes défini dans le paquetage java.util. Il facilite la définition des classes de structure de données via l’héritage. Les méthodes iterator() et size() sont déclarées comme abstract dans la classe AbstractCollection parce qu’elles sont utilisées par d’autres méthodes telles que toString() et isEmpty() implémentées dans cette classe. Ces autres méthodes peuvent ainsi être utilisées dans des sous-classes concrètes. Un itérateur est un objet qui passe séquentiellement d’un composant à l’autre via une structure de collection et qui fournit l’accès à ces éléments.
EXERCICES D’ENTRAÎNEMENT
EXERCICES D’ENTRAÎNEMENT
5.1
Implémentez le constructeur suivant pour la classe Bag (reportez-vous à l’exemple 5.3) : • public Bag(int capacity) • // construit un sac vide avec la capacité donnée
5.2
Implémentez le constructeur suivant pour la classe Bag (reportez-vous à l’exemple 5.3) : • public Bag(Object[] objects) • // construit un sac contenant les objets du • // tableau donné en doublant sa capacité
5.3
Implémentez le constructeur suivant pour la classe Bag (reportez-vous à l’exemple 5.3) : • public boolean addAll(Collection collection) • // ajoute tous les objets de la collection donnée • // dans le sac
5.4
Implémentez la méthode suivante pour la classe Bag (reportez-vous à l’exemple 5.3) : • public void clear() • // supprime tous les objets du sac
5.5
Implémentez la méthode suivante pour la classe Bag (reportez-vous à l’exemple 5.3) : • public boolean containsAll(Collection collection) • // renvoie true si chaque objet de la collection donnée • // est égal à un objet du sac ; c’est-à-dire, • // si la collection donnée est un sous-ensemble du sac ;
5.6
Implémentez la méthode suivante pour la classe Bag (reportez-vous à l’exemple 5.3) : • private static int frequency(Collection x, Object object) • // renvoie le nombre d’objets de la collection donnée • // qui sont égaux à l’objet donné
5.7
Implémentez la méthode suivante pour la classe Bag (reportez-vous à l’exemple 5.3) : • public int hashCode() • // renvoie un code de hachage pour le sac qui est la somme • // des codes de hachage de ses éléments
Révision et entraînement
5.8
Implémentez la méthode suivante pour la classe Bag (reportez-vous à l’exemple 5.3) : • public boolean remove(Object object) • // supprime l’un des objets donné du sac; • // renvoie true si le sac a été modifié;
5.9
Implémentez la méthode suivante pour la classe Bag (reportez-vous à l’exemple 5.3) : • public boolean removeAll(Collection collection) • // supprime du sac tous les objets se trouvant également dans la • // collection donnée, réduisant ainsi le sac à son • // intersection théorique avec cette collection; • // renvoie true si le sac a été modifié;
5.10 Implémentez la méthode suivante pour la classe Bag (reportez-vous à l’exemple 5.3) : • public boolean retainAll(Collection collection) • // supprime du sac tous les objets ne se trouvant pas dans la • // collection donnée, réduisant ainsi le sac • // à son complément théorique par rapport à la collection; • // renvoie true si le sac a été modifié;
5.11 Implémentez la méthode suivante pour la classe Bag (reportez-vous à l’exemple 5.3) : • public Object[] toArray(Object[] objects) • // renvoie un tableau dont les éléments se trouvent dans le sac • // s’il est plus long que le tableau object[] donné; • // sinon, le tableau donné est renvoyé après suppression de • // tous ses éléments, puis il est chargé avec les éléments du sac • // avec null pour combler les vides;
5.12 Implémentez la méthode suivante pour la classe Bag (reportez-vous à l’exemple 5.3) : • public String toString() • // renvoie une chaîne avec le contenu du sac
¿
SOLUTIONS
SOLUTIONS
5.1
L’implémentation du constructeur (int) pour la classe Bag est la suivante : • public Bag(int capacity) • { // construit un sac vide avec la capacité donnée • objects = new Object[capacity]; •}
5.2
L’implémentation du constructeur Bag(Object[]) pour la classe Bag est la suivante : • public Bag(Object[] objects) • { // construit un sac contenant les objets du • // tableau donné en doublant sa capacité • this.objects = new Object[2*objects.length]; • for (int i=0; i
5.3
L’implémentation de la méthode addAll(Collection) pour la classe Bag : • public boolean addAll(Collection collection) • { // ajoute tous les objets de la collection donnée dans le sac
111
112
Collections • resize(2*collection.size()); • for (Iterator it = collection.iterator(); it.hasNext(); ) • objects[size++] = it.next(); • return true; •}
5.4
L’implémentation de la méthode clear() pour la classe Bag est la suivante : • public void clear() • { // supprime tous les objets du sac • for (int i=0; i<size; i++) • objects[i] = null; • size = 0; •}
5.5
L’implémentation de la méthode containsAll(Collection) pour la classe Bag est la suivante : • public boolean containsAll(Collection collection) • { // renvoie true si chaque objet de la collection donnée • // est égal à un objet du sac, c’est-à-dire • // si la collection donnée est un sous-ensemble du sac; • for (Iterator it = collection.iterator(); it.hasNext(); ) • if (!this.contains(it.next())) return false; • return true; •}
5.6
L’implémentation de la méthode frequency(Collection,Object) pour la classe Bag est la suivante : • private static int frequency(Collection x, Object object) • { // renvoie le nombre d’objets de la collection donnée • // étant égaux à l’objet donné • int count=0; • for (Iterator it = x.iterator(); it.hasNext(); ) • if (object.equals(it.next())) ++count; • return count; •}
5.7
L’implémentation de la méthode hashCode() pour la classe Bag est la suivante : • public int hashCode() • { // renvoie un code de hachage pour le sac égal à la somme • // de tous les codes de hachage de ses éléments • int code=0; • for (int i=0; i<size; i++) • code += objects[i].hashCode(); • return code; •}
5.8
L’implémentation de la méthode remove(Object) pour la classe Bag est la suivante : • public boolean remove(Object object) • { // supprime l’un des objets donnés du sac; • // renvoie true si le sac a été modifié; • for (int i=0; i<size; i++) • if (object.equals(objects[i])) • { objects[i] = objects[--size]; • return true; • } • return false; •}
Révision et entraînement
5.9
113
L’implémentation de la méthode removeAll(Collection) pour la classe Bag est la suivante : • public boolean removeAll(Collection collection) • { // supprime du sac tous les objets se trouvant également • // dans la collection donnée, réduisant ainsi l’intersection • // théorique avec cette collection; • // renvoie true si le sac a été modifié; • boolean modified=false; • • for (Iterator it = collection.iterator(); it.hasNext(); ) • if (this.remove(it.next())) modified = true; • return modified; •}
5.10 L’implémentation de la méthode retainAll(Collection) pour la classe Bag est la sui-
vante : • public boolean retainAll(Collection collection) • { // supprime du sac tous les objets ne se trouvant pas dans • // la collection donnée, réduisant ainsi le sac • // à son complément théorique par rapport à la collection; • // renvoie true si le sac a été modifié; • boolean modified=false; • • for (int i=0; i<size; i++) • if (!collection.contains(objects[i])) • { remove(objects[i]); • modified = true; • } • return modified; •}
5.11 L’implémentation de la méthode toArray(Object[]) pour la classe Bag est la suivante : • public Object[] toArray(Object[] objects) • { // renvoie un tableau dont les éléments sont dans le sac • // s’il est plus grand que le tableau object[] donné; • // sinon, le tableau donné est renvoyé après suppression • // de tous ses éléments, puis il est chargé avec les éléments • // du sac et null pour combler les vides; • if (size > objects.length) objects = this.toArray(); • • { for (int i=0; i<size; i++) • objects[i] = this.objects[i]; • for (int i=size; i
5.12 L’implémentation de la méthode toString() pour la classe Bag est la suivante : • public String toString() • { // renvoie une chaîne avec le contenu du sac • String s="{ "; • if (size>0) s += this.objects[0]; • for (int i=1; i<size; i++) • s += ", " + this.objects[i]; • return s + " }"; •}
Chapitre 6
Piles Une pile est un conteneur qui implémente le protocole dernier entré, premier sorti (LIFO, Last-in-First-Out). Cela signifie que le seul objet accessible dans le conteneur est le dernier à avoir été entré. Pour comprendre de quoi il retourne, imaginez que vous souhaitiez lire le dernier livre d’une pile. Avant de l’atteindre, vous devrez retirer tous les livres qui se trouvent au-dessus.
Canada Suède Russie Mexique France Canada Brésil
6.1 CLASSE JAVA Stack Comme nous l’avons déjà vu dans le diagramme de la section 5.1, le framework de collections Java comprend une classe Stack qui est définie de la façon suivante dans le paquetage java.util :
Object AbstractCollection
public class Stack extends Vector { public boolean empty() { return size()==0; } public Object peek() { if (size()==0) throw new EmptyStackException(); return elementAt(size()-1); } public Object pop() { Object object = peek(); removeElementAt(size()-1); return object; } public Object push(Object object) { addElement(object); return object; } public int search(Object object) { int i=lastIndexOf(object); if (i<0) return -1; // l’objet n’est pas dans la pile return size() - i; }
AbstractList Vector Stack
116
Piles
public Stack() { } }
La classe Stack est une sous-classe de Vector (reportez-vous au chapitre 2). Elle implémente une pile sous forme de vecteur, le dernier élément de ce dernier se trouvant en haut de la pile. La méthode empty() renvoie true si et seulement si le nombre d’éléments de la pile est égal à zéro. La méthode peek() renvoie l’objet situé en haut de la pile sans le supprimer. Elle utilise la méthode Vector.elementAt(int) pour accéder au dernier élément du vecteur. Si la pile est vide, l’exception EmptyStackException est lancée. La méthode pop() renvoie l’objet du haut de la pile après l’avoir supprimé. Elle utilise la méthode Vector.removeElementAt(int). Étant donné que cette méthode appelle la méthode peek(), elle lance également une exception EmptyStackException si la pile est vide. La méthode push(Object) insère l’objet donné en haut de la pile. Elle utilise la méthode Vector.addElementAt(Object) qui ajoute l’élément à la fin du vecteur. La méthode search(Object) renvoie la position de l’objet donné dans la pile ou –1 si l’objet n’est pas dans la pile. Elle appelle la méthode Vector.lastIndexOf(Object) qui utilise la méthode equals() pour comparer l’objet donné à ceux du vecteur. Si plusieurs objets sont égaux à l’objet donné, c’est la position du dernier objet de la pile qui est renvoyée, c’est-à-dire celle de l’objet le plus près du haut de la pile. Les numéros des positions sont calculés à l’aide de l’indexation de base 1, c’est pourquoi l’élément supérieur de la pile est à la position 1.
Exemple 6.1 Visualiser une pile vide public class Ex0601 { public static void main(String[] args) { java.util.Stack stack = new java.util.Stack(); System.out.println("stack.size() = " + stack.size()); System.out.println("stack.peek() = " + stack.peek()); } } stack.size() = 0 java.util.EmptyStackException at java.util.Stack.peek(Stack.java:86) at Ex0601.main(Ex0601.java:10)
Ce programme illustre le lancement d’une exception EmptyStackException si la méthode peek() est appelée sur une pile vide.
Exemple 6.2 Gérer une exception EmptyStackException import java.util.Stack; public class Test { public static void main(String[] args) { Stack stack = new Stack(); print(stack); } private static void print(Stack stack) { System.out.println("stack.size() = " + stack.size()); try { System.out.println("stack.peek() = " + stack.peek()); }
117
Classe Java Stack
catch(java.util.EmptyStackException e) { System.out.println(e + " : La pile est vide."); } } } stack.size() = 0 java.util.EmptyStackException : La pile est vide.
Ce programme illustre un procédé simple de gestion d’une exception EmptyStackException.
Exemple 6.3 Tester les méthodes push() et pop() import java.util.Stack; public class Ex0603 { public static void main(String[] args) { Stack stack = new Stack(); stack.push("Angleterre"); stack.push("Canada"); stack.push("France"); stack.push("Mexique"); stack.push("Russie"); stack.push("Danemark"); stack.push("Angleterre"); stack.push("Turquie"); print(stack); System.out.println("stack.search(\"Angleterre\") = " + stack.search("Angleterre")); System.out.println("stack.pop() = " + stack.pop()); System.out.println("stack.pop() = " + stack.pop()); print(stack); System.out.println("stack.search(\"Angleterre\") = " + stack.search("Angleterre")); } private static void print(Stack stack) { System.out.println(stack); System.out.println("stack.size() = " + stack.size()); try { System.out.println("stack.peek() = " + stack.peek()); } catch(java.util.EmptyStackException e) { System.out.println(e + " : La pile est vide."); } } } [Angleterre, Canada, France, ➥ Turquie] stack.size() = 8 stack.peek() = Turquie stack.search("Angleterre") = stack.pop() = Turquie stack.pop() = Angleterre [Angleterre, Canada, France, stack.size() = 6 stack.peek() = Danemark stack.search("Angleterre") =
Mexique, Russie, Danemark, Angleterre,
2 Mexique, Russie, Danemark] 6
118
Piles
Après avoir poussé les huit objets (toutes les chaînes) dans la pile, ce programme appelle sa méthode locale print(Stack) afin d’afficher les données relatives à la pile. Il recherche ensuite "Angleterre", retire "Turquie" du sommet de la pile, puis appelle à nouveau print(Stack). Notez que search(Object) renvoie 2, ce qui signifie qu’il existe une copie de "Angleterre" en deuxième position à partir du haut de la pile (une autre copie se trouve en bas de la pile). La méthode pop() est ensuite appelée deux fois, ce qui permet de supprimer la première occurrence de "Turquie", puis "Angleterre" de la pile. L’appel final de print(Stack) indique que la pile est composée de six éléments, avec "Danemark" en haut et "Angleterre" en sixième position à partir du haut. Notez que l’appel System.out.println(stack) invoque la méthode Vector.toString() qui renvoie une chaîne affichant une liste d’éléments délimités par des crochets [].
6.2 APPLICATIONS DES PILES Bien que la structure de données stack soit l’une des plus simples, elle est fondamentale dans certaines applications importantes, notamment dans les exemples qui vont suivre. Une expression arithmétique est qualifiée de notation suffixée (ou de notation polonaise inversée, RPN) si chaque opérateur est placé après ses opérandes. Par exemple, l’expression suffixée de 3*(4 + 5) est la suivante : 3 4 5 + * (l’expression 3*(4 + 5) est qualifiée d’expression infixée). Les expressions suffixées sont plus faciles à traiter par une machine que les expressions infixées et ce sont les calculatrices RPN qui peuvent effectuer ce type de traitement.
Exemple 6.4 Utiliser une calculatrice RPN Ce programme analyse les expressions suffixées et effectue les calculs indiqués. Il a recours à deux piles, la première pour cumuler les opérateurs, et la seconde pour cumuler les opérandes : import java.util.Stack; import java.io.*; public class Ex0604 { public static void main(String[] args) { boolean quit=false; String input; double x, y, z; Stack operands = new Stack(); while (!quit) { input = getString("RPN> "); switch (input.charAt(0)) { case ’Q’: quit = true; break; case ’+’: y = Double.parseDouble((String)operands.peek()); operands.pop(); x = Double.parseDouble((String)operands.peek()); operands.pop(); z = x + y; System.out.println("\t" + x + "+" + y + " = " + z); operands.push(new Double(z).toString()); break; case ’-’: y = Double.parseDouble((String)operands.peek());
Applications des piles
119
operands.pop(); x = Double.parseDouble((String)operands.peek()); operands.pop(); z = x - y; System.out.println("\t" + x + "-" + y + " = " + z); operands.push(new Double(z).toString()); break; case ’*’: y = Double.parseDouble((String)operands.peek()); operands.pop(); x = Double.parseDouble((String)operands.peek()); operands.pop(); z = x * y; System.out.println("\t" + x + "*" + y + " = " + z); operands.push(new Double(z).toString()); break; case ’/’: y = Double.parseDouble((String)operands.peek()); operands.pop(); x = Double.parseDouble((String)operands.peek()); operands.pop(); z = x / y; System.out.println("\t" + x + "/" + y + " = " + z); operands.push(new Double(z).toString()); break; default: operands.push(input); } } }
private static String getString(String prompt) { System.out.print(prompt); InputStreamReader iSReader = new InputStreamReader(System.in); BufferedReader bReader = new BufferedReader(iSReader); String input=""; try { input = bReader.readLine(); } catch(IOException e) { System.out.println(e); } return input; }
Ce programme traite l’expression suffixée 3 4 5 + * 10 / 1 – qui représente l’expression infixée 3*(4 + 5)/10 - 1. Chaque calcul intermédiaire est imprimé, c’est-à-dire : 4 + 5 = 9, 3*9 = 27, 27/10 = 2,7 et 2,7 - 1 = 1,7. À chaque itération de la boucle while, le programme imprime l’invite RPN>, puis il lit une chaîne d’entrée. Il utilise le premier caractère de cette chaîne afin de décider quelle opération effectuer. S’il s’agit d’un Q, le programme s’arrête. En revanche, s’il s’agit d’un opérateur +, -, * ou /, il procède à l’opération correspondante. S’il s’agit d’une autre valeur, le programme suppose que l’entrée est un opérande numérique. Dans ce cas, il utilise stringstream pour envoyer la valeur numérique dans la variable x, puis il la pousse dans la pile d’opérandes. Lorsque l’un des quatre opérateurs est entré, il dépile les deux derniers nombres de la pile d’opérandes, il effectue l’opération arithmétique demandée, il imprime le résultat, puis il le pousse dans la pile d’opérandes.
120
Piles
RPN> RPN> RPN> RPN>
3 4 5 + 4.0+5.0 = 9.0
RPN> * 3.0*9.0 = 27.0 RPN> 10 RPN> / 27.0/10.0 = 2.7 RPN> 1 RPN> 2.7–1 = 1.7000000000000002 RPN> Q
Généralement, les êtres humains préfèrent les notations infixées à celles suffixées pour les opérations arithmétiques. C’est pourquoi nous vous proposons l’exemple suivant qui convertit une expression infixée donnée en une expression suffixée.
Exemple 6.5 Convertir une expression infixée en expression suffixée import java.util.Stack; import java.io.*; public class Ex0605 { public static void main(String[] args) { try { Stack stack = new Stack(); InputStreamReader reader = new InputStreamReader(System.in); StreamTokenizer tokens = new StreamTokenizer(reader); tokens.ordinaryChar(’/’); // sinon ce serait un commentaire tokens.eolIsSignificant(true); // false est la valeur par défaut int tokenType; System.out.print("Entrez une expression infixée : "); while ((tokenType=tokens.nextToken()) != StreamTokenizer.TT_EOL) { char ch = (char)tokenType; if (tokenType==StreamTokenizer.TT_NUMBER) System.out.print(tokens.nval + " "); else if (ch==’+’ || ch==’-’ || ch==’*’ || ch==’/’) stack.push(new Character(ch)); else if (ch==’)’) System.out.print((Character)stack.pop()+" "); } while (!stack.empty()) System.out.print((Character)stack.pop()+" "); } catch (Exception e) { System.out.println(e); } } } Entrer une expression infixée : (80 - 30)*(40 + 50/10) 80.0 30.0 - 40.0 50.0 10.0 / + *
Supprimer la récursivité
121
L’entrée est analysée par un objet tokens de type StreamTokenizer associé à l’objet InputStreamReader. ordinaryChar(’/’) est appelée et reconnaît l’opérateur de division « / » comme caractère. La méthode eolIsSignificant(true) est ensuite appelée de façon à ce que la constante de classe TT_EOL puisse contrôler la boucle d’analyse et la terminer lorsque le caractère de fin de ligne est détecté. À chaque itération de la boucle while, l’objet tokens obtient l’unité suivante du flux d’entrée, extrait sa représentation char et l’insère dans la variable ch. Les actions suivantes de cet objet dépendent de sa nature : un opérande numérique, l’un des quatre opérateurs arithmétiques ou le caractère parenthèse droite ’)’. S’il s’agit d’un opérande numérique, il est imprimé immédiatement parce que les opérandes figurent devant les opérateurs dans les notations suffixées. S’il s’agit d’un opérateur arithmétique, il est poussé dans la pile. Et enfin, s’il s’agit du caractère parenthèse droite, l’opérateur situé en haut de la pile est extrait est imprimé. Attention, dans le cas présent, l’expression d’entrée doit être mise entre parenthèses. Pensez également à insérer un espace devant l’opérateur de soustraction pour qu’il soit reconnu comme opérateur de soustraction binaire et non comme opérateur de négation unaire.
6.3 SUPPRIMER LA RÉCURSIVITÉ Le système d’exploitation d’un ordinateur exécute une fonction récursive grâce à une pile qui lui permet de stocker l’état d’exécution courant chaque fois qu’il effectue un appel récursif. Par la suite, chaque fois que l’appel récursif provoque le renvoi d’une valeur, il dépile l’état de la pile d’exécution afin de pouvoir recommencer là où il en était. Étant donné que les piles sont utilisées par le système d’exploitation pour exécuter une fonction récursive, il est évident que le programmeur doit être capable de réécrire une fonction récursive de façon à utiliser une pile explicite au lieu d’effectuer des appels récursifs.
Exemple 6.6 Implémenter itérativement les tours de Hanoi Ce programme équivaut au programme de récursivité présenté dans l’exemple 4.15 : public class Ex0606 { public static void main(String[] args) { hanoi(3,’A’,’B’,’C’); // jouer avec 3 disques } private static void hanoi(int n, char x, char y, char z) { java.util.Stack stack = new java.util.Stack(); stack.push(new Quad(n,x,y,z)); while (!stack.empty()) { Quad quad = (Quad)stack.pop(); n = quad.n; x = quad.a; y = quad.b; z = quad.c; if (n == 1) System.out.println ("Déplacer le disque supérieur de la tour " + quad.a + " vers la tour " + quad.c); else { stack.push(new Quad(n-1,y,x,z)); stack.push(new Quad(1,x,y,z)); stack.push(new Quad(n-1,x,z,y)); } } } }
122
Piles
class Quad { public int n; public char a, b, c; public Quad(int n, char a, char b, char c) { this.n = n; this.a = a; this.b = b; this.c = c; } } Déplacer Déplacer Déplacer Déplacer Déplacer Déplacer Déplacer
le le le le le le le
disque disque disque disque disque disque disque
supérieur supérieur supérieur supérieur supérieur supérieur supérieur
de de de de de de de
la la la la la la la
tour tour tour tour tour tour tour
A A C A B B A
vers vers vers vers vers vers vers
la la la la la la la
tour tour tour tour tour tour tour
C B B C A C C
Chaque appel récursif intégré à la version récursive de la méthode hanoi(int, char, char, char) est remplacé par un appel stack.push(Quad) et chaque retour d’un appel récursif est remplacé par un appel stack.pop(Quad). La classe Quad contient un quadruple composé d’un entier et de trois caractères.
?
QUESTIONS DE RÉVISION
QUESTIONS DE RÉVISION
6.1 6.2
6.3
6.4
¿
Pourquoi les piles sont-elles qualifiées de structures LIFO ? Peut-on qualifier les piles de structures : a. LILO b. FILO Définissez les expressions suivantes : a. notation préfixée ; b. notation infixée ; c. notation suffixée. Dans le cadre des notations suffixées, quelle expression suivante peut être considérée comme vraie : a. x y + z + = x y z + + b. x y + z - = x y z – + c. x y – z + = x y z + – d. x y – z – = x y z – –
RÉPONSES
RÉPONSES
6.1
Les piles sont qualifiées de structures LIFO parce que le dernier élément inséré dans la pile est toujours le premier à en être supprimé. LIFO est l’acronyme de l’expression anglaise Last-InFirst-Out, c’est-à-dire dernier entré, premier sorti.
Révision et entraînement
123
6.2
a. Une pile ne peut pas être une structure LILO (Last-In-Last-Out, Dernier entré, dernier sorti), c’est-à-dire le contraire du protocole Dernier entré, premier sorti. b. Une pile peut être une structure FILO (First-In-Last-Out, Premier entré, dernier sorti) qui est identique au protocole Dernier entré, premier sorti.
6.3
a. La notation préfixée des expressions arithmétiques place les opérateurs binaires devant leurs deux opérandes. Par exemple, « x + 2 » s’écrit sous la forme « + x 2 » en notation préfixée. En mathématiques, la notation fonctionnelle standard utilise ce format préfixé, par exemple pour f(x), sin x, etc. b. La notation infixée des expressions arithmétiques place les opérateurs binaires entre leurs opérandes. Il s’agit du format standard des expressions arithmétiques telles que « x + 2 ». c. La notation suffixée des expressions arithmétiques place les opérateurs binaires après leurs deux opérandes. Par exemple, l’expression « x + 2 » s’écrit « x 2 + » en notation suffixée. En mathématiques, la fonction factorielle utilise la notation suffixée : n!.
6.4
a. b. c. d.
?
Vraie parce que (x + y) + z = x + (y + z). Vraie parce que (x + y) – z = x + (y – z). Fausse parce que (x – y) + z x - (y + z). Fausse parce que (x – y) – z x – (y – z).
EXERCICES D’ENTRAÎNEMENT
EXERCICES D’ENTRAÎNEMENT
6.1
Tracez le code suivant en faisant apparaître le contenu de la pile après chaque appel : • Stack stack = new Stack(); • stack.push(new Character(’A’)); • stack.push(new Character(’B’)); • stack.push(new Character(’C’)); • stack.pop(); • stack.pop(); • stack.push(new Character(’D’)); • stack.push(new Character(’E’)); • stack.push(new Character(’F’)); • stack.pop(); • stack.push(new Character(’G’)); • stack.pop(); • stack.pop(); • stack.pop();
6.2
Convertissez les expressions préfixées suivantes en expressions infixées : a. – / + * a b c d e b. / – a b * c + d e c. / a + b * c – d e
6.3
Convertissez les expressions préfixées de l’exercice 6.2 en expressions suffixées.
6.4
Convertissez les expressions infixées suivantes en expressions préfixées : a. (a + b) – (c / (d + e)) b. a / ((b / c) * (d – e)) c. (a / (b / c)) * (d – e)
124
Piles
6.5
Convertissez les expressions infixées de l’exercice 6.4 en expressions suffixées.
6.6
Convertissez les expressions suffixées suivantes en expressions préfixées : a. a b + c d – / e + b. a b c + d e – * – c. a b c d e / / / /
6.7
Convertissez les expressions suffixées de l’exercice 6.6 en expressions infixées.
6.8
Écrivez la méthode suivante en utilisant uniquement le constructeur et les méthodes push(), peek(), pop() et empty() de la classe Stack : • private static void reverse(Stack stack); • // inverse le contenu de la pile donnée
6.9
Écrivez la méthode suivante en utilisant uniquement le constructeur et les méthodes push(), peek(), pop() et empty() de la classe Stack : • private static Stack reversed(Stack stack); • // renvoie une nouvelle pile contenant les mêmes éléments • // que ceux de la pile donnée, mais dans l’ordre inverse
6.10 Écrivez la méthode suivante en utilisant uniquement le constructeur et les méthodes push(), peek(), pop() et empty() de la classe Stack : • public Object penultimate(Stack stack); • // renvoie le deuxième élément de la pile donnée en partant du haut
6.11 Écrivez la méthode suivante en utilisant uniquement le constructeur et les méthodes push(), peek(), pop() et empty() de la classe Stack : • public Object bottom(); • // renvoie l’élément inférieur de la pile
6.12 Écrivez la méthode suivante en utilisant uniquement le constructeur et les méthodes push(), peek(), pop() et empty() de la classe Stack : • public Object popBottom(); • // supprime et renvoie l’élément situé en bas de la pile
6.13 Écrivez la méthode reverse() de l’exercice 6.8 en utilisant les méthodes Vector héritées. 6.14 Écrivez la méthode reverse() de l’exercice 6.9 en utilisant les méthodes Vector héritées. 6.15 Écrivez la méthode penultimate() de l’exercice 6.10 en utilisant les méthodes Vector héri-
tées. 6.16 Écrivez la méthode bottom() de l’exercice 6.11 en utilisant les méthodes Vector héritées. 6.17 Écrivez la méthode popBottom() de l’exercice 6.12 en utilisant les méthodes Vector héritées. 6.18 Modifiez l’exemple 6.5 de façon à ce qu’il utilise une pile de valeurs primitives char des références Object et implémentez votre propre classe Stack dans ce but. Utilisez un tableau pour stocker les valeurs char.
125
Révision et entraînement
¿
SOLUTIONS
SOLUTIONS
6.1
La trace est la suivante :
s.push('A')
s.push('B') A
s.pop()
s.push('E')
s.push('G')
B A
E D A
G E D A
s.pop()
s.push('C')
s.push('D') A
s.push('F')
s.pop()
6.2
a. (a * b + c) / (d – e) b. (a – b) / (c * ( d + e )) c. a / (b + (c * (d – e)))
6.3
a. a b * c + d / e – b. a b – c d e + * / c. a b c d e – * + /
6.4
a. (a + b) – (c / (d + e)) = – + a b / c + d e b. a / ((b / c) * (d – e)) = / a * / b c – d e c. (a / (b / c)) * (d – e) = * / a / b c – d e
6.5
a. (a + b) – (c / (d + e)) = a b + c d e + / – b. a / ((b / c) * (d – e)) = a b c / d e – * / c. (a / (b / c)) * (d – e) = a b c / / * d e – *
6.6
a. (a + b) / (c – d) + e b. a – (b + c) * (d – e) c. a / (b / (c / (d / e)))
6.7
a. + / + a b – c d e b. – a * + b c – d e c. / a / b / c / d e La méthode suivante inverse le contenu d’une pile :
6.8
B A
F E D A
E D A
• private static void reverse(Stack stack) • { Stack tempStack1 = new Stack();
s.pop()
s.pop()
C B A
D A
E D A
D A
126
Piles • • • • • • • •}
6.9
while(!stack.empty()) tempStack1.push(stack.pop()); Stack tempStack2 = new Stack(); while(!tempStack1.empty()) tempStack2.push(tempStack1.pop()); while(!tempStack2.empty()) stack.push(tempStack2.pop());
La méthode suivante inverse le contenu d’une pile : • private static Stack reversed(Stack stack) • { Stack tempStack = new Stack(); • Stack newStack = new Stack(); • while(!stack.empty()) • { Object x = stack.pop(); • tempStack.push(x); • newStack.push(x); • } • while(!tempStack.empty()) • stack.push(tempStack.pop()); • return newStack; •}
6.10 La méthode suivante renvoie le deuxième élément d’une pile en partant du haut : • private static Object penultimate(Stack stack) • { Object x1 = stack.pop(); • Object x2 = stack.pop(); • stack.push(x2); • stack.push(x1); • return x2; •}
6.11 La méthode suivante renvoie l’élément inférieur d’une pile : • private static Object bottom(Stack stack) • { Object x = null; • Stack tempStack = new Stack(); • while(!stack.empty()) • { x = stack.pop(); • tempStack.push(x); • } • while(!tempStack.empty()) • stack.push(tempStack.pop()); • return x; •}
6.12 La méthode suivante supprime et renvoie l’élément inférieur d’une pile : • private static Object popBottom(Stack stack) • { Stack tempStack = new Stack(); • Object x = null; • if (!stack.empty()) x = stack.pop(); • while(!stack.empty()) • { tempStack.push(x); • x = stack.pop(); • } • while(!tempStack.empty()) • stack.push(tempStack.pop()); • return x; •}
Révision et entraînement
127
6.13 La méthode suivante utilise les méthodes Vector pour inverser le contenu d’une pile : • private static void reverse(Stack stack) • { Stack copiedStack = (Stack)stack.clone(); • stack.clear(); • while(!copiedStack.empty()) • stack.push(copiedStack.pop()); •}
6.14 La méthode suivante utilise les méthodes Vector pour renvoyer le contenu inversé d’une pile : • private static Stack reversed(Stack stack) • { Stack copiedStack = (Stack)stack.clone(); • Stack newStack = new Stack(); • while(!copiedStack.empty()) • newStack.push(copiedStack.pop()); • return newStack; •}
6.15 La méthode suivante utilise les méthodes Vector pour renvoyer le deuxième élément à partir du
haut de la pile : • private static Object penultimate(Stack stack) • { if (stack.size()<2) return null; • return stack.elementAt(stack.size()-2); •}
6.16 La méthode suivante utilise les méthodes Vector pour renvoyer l’élément inférieur d’une pile : • private static Object bottom(Stack stack) • { return stack.firstElement(); •}
6.17 La méthode suivante utilise les méthodes Vector pour supprimer et renvoyer l’élément inférieur
d’une pile : • private static Object popBottom(Stack stack) • { return stack.remove(0); •}
6.18 L’exemple 6.5 modifié à l’aide d’une pile de valeurs primitives char est le suivant : • import java.io.*; • class CharStack • { private char[] s = new char[1000]; • private int top=-1; • public boolean empty() { return top<0; } • public char peek() { return s[top]; } • public char pop() { return s[top--]; } • public void push(char ch) { s[++top] = ch; } •} • • public class Tmp • { public static void main(String[] args) • { try • { CharStack stack = new CharStack(); • InputStreamReader reader = new InputStreamReader(System.in); • StreamTokenizer tokens = new StreamTokenizer(reader); • tokens.ordinaryChar(’/’); • tokens.eolIsSignificant(true); • int tokenType; • System.out.print("Enter an infix expression: ");
128
Piles • • • • • • • • • • • • • • • • • •}
while ((tokenType=tokens.nextToken()) != StreamTokenizer.TT_EOL) { char ch = (char)tokenType; if (tokenType==treamTokenizer.TT_NUMBER) System.out.print(tokens.nval + " "); else if (ch==’+’ || ch==’-’ || ch==’*’ || ch==’/’) stack.push(ch); else if (ch==’)’) System.out.print(stack.pop()+" "); } while (!stack.empty()) System.out.print(stack.pop()+" "); } catch (Exception e) { System.out.println(e); } }
Chapitre 7
Files Une file est un conteneur qui implémente le protocole Premier entré, premier sorti (FIFO, First-In-First-Out). Cela signifie que le seul objet accessible dans le conteneur est celui qui a été inséré en premier. Pour comprendre de quoi il retourne, imaginez un groupe de personnes qui font la queue pour aller voir un film : la prochaine personne à entrer dans la salle de cinéma sera celle qui est arrivée avant toutes les autres.
7.1 FRAMEWORK DES FILES Un framework est un jeu d’interfaces et de classes abstraites associées via l’extension et l’implémentation. En outre, il offre les diverses possibilités d’implémentations des types de données abstraites. Le framework de collections Java (reportez-vous à la section 5.1) est composé de listes, de jeux et de mappes. Si la bibliothèque standard Java ne propose pas de framework de files à proprement parler, le framework de collections vous indique tout de même au programmeur comment en construire un. À l’instar des interfaces List et Set, l’interface Queue Object AbstractCollection Collection est une sous-interface de ColQueue AbstractQueue lection (reportez-vous à la ArrayQueue section 5.2) et elle hérite donc LinkedQueue des 15 spécifications de méthodes de cette dernière : public interface Collection { public boolean add(Object); public boolean addAll(Collection); public void clear(); public boolean contains(Object); public boolean containsAll(Collection); public boolean equals(Object); public int hashCode(); public boolean isEmpty(); public Iterator iterator(); public boolean remove(Object); public boolean removeAll(Collection); public boolean retainAll(Collection); public int size();
130
Files
public Object[] toArray(); public Object[] toArray(Object[]); }
Exemple 7.1 Une interface queue L’interface suivante est destinée aux files qui ajoutent les quatre méthodes traditionnelles définissant leur comportement : public interface Queue extends Collection { public Object dequeue(); public Object enqueue(Object object); public Object getBack(); public Object getFront(); }
Dans le cas présent, dequeue signifie supprimer l’objet situé en tête de file, et enqueue insérer le nouvel objet en queue de la file.
Exemple 7.2 Utiliser une file Le diagramme ci-contre illustre l’évolution d’une file suite aux appels des méthodes enqueue (Object) et dequeue() dans l’ordre indiqué ci-après : q.enqueue("Amin"); q.enqueue("Bush"); q.enqueue("Chen"); q.enqueue("Diaz"); q.dequeue(); q.dequeue(); q.enqueue("Ford"); q.enqueue("Gore"); q.dequeue();
Dans le cas présent, les éléments situés en tête de file se trouvent dans la colonne de gauche, ceux situés en queue se trouvent dans la colonne de droite. C’est la raison pour laquelle, après le troisième appel de la méthode dequeue(), un appel de la méthode getFront() renverrait "Diaz" et un appel de la méthode getBack() renverrait "Gore". Sur le modèle du framework de collections Java (reportez-vous à la section 5.1), nous implémentons l’interface Queue comme sous-classe abstraite de la classe AbstractCollection, le tableau concerné et les implémentations liées devenant ensuite des sous-classes de cette classe de base :
q.enqueue("Amin")
Amin
q.enqueue("Bush")
Amin Bush
q.enqueue("Chen")
Amin Bush Chen
q.enqueue("Diaz")
Amin Bush Chen Diaz
q.dequeue()
Bush Chen Diaz
q.dequeue()
Chen Diaz
q.enqueue("Ford")
Chen Diaz Ford
q.enqueue("Gore")
Chen Diaz Ford Gore
q.dequeue()
Diaz Ford Gore
Exemple 7.3 Une classe AbstractQueue import java.util.*; public abstract class AbstractQueue extends AbstractCollection implements Queue
131
Framework des files
{ protected AbstractQueue() { } public abstract Object dequeue(); public abstract Object enqueue(Object object); public boolean equals(Object object) { if (object == this) return true; if (!(object instanceof AbstractQueue)) return false; AbstractQueue abstractQueue = (AbstractQueue) object; if (abstractQueue.size() != size()) return false; return containsAll(abstractQueue); } public abstract Object getBack(); public abstract Object getFront(); public int hashCode() { int n = 0; for (Iterator it = iterator(); it.hasNext(); ) { Object object = it.next(); if (object != null) n += object.hashCode(); } return n; } public abstract Iterator iterator(); public abstract int size(); }
Cette classe abstraite implémente le constructeur par défaut et remplace les méthodes equals (Object) et hashCode() de la classe Object. Les six autres méthodes sont déclarées comme abstraites ; c’est pourquoi les sous-classes concrètes sont chargées de leur implémentation. L’interface Queue requiert la présence des méthodes dequeue(), enqueue(Object), getBack() et getFront(), tandis que la classe de base AbstractCollections requiert l’implémentation des méthodes iterator() et size(). Étant une sous-classe de AbstractCollections, AbstractQueue hérite des méthodes concrètes suivantes (reportez-vous à la section 5.3) : public public public public public public public public public public public
boolean void boolean boolean boolean boolean boolean boolean Object[] Object[] String
addAll(Collection); clear(); contains(Object); containsAll(Collection); isEmpty(); remove(Object); removeAll(Collection); retainAll(Collection); toArray(); toArray(Object[]); toString();
La méthode isEmpty() utilise la méthode size(), contrairement aux dix autres méthodes concrètes qui utilisent la méthode iterator(). C’est la raison pour laquelle les sous-classes doivent implémenter les méthodes size() et iterator().
132
Files
7.2 IMPLÉMENTATION CONTIGUË Les tableaux, c’est-à-dire le procédé contigu, constituent la méthode la plus simple d’implémentation d’une file.
Exemple 7.4 Classe ArrayQueue import java.util.*; public class ArrayQueue extends AbstractQueue { protected Object[] objects; protected int front=0; protected int back=0; protected int capacity=16; // INVARIANTS : objects[i] == null pour 0 <= i < front; // objects[i] != null pour tête <= i < fin; // objects[i] == null pour fin <= i < capacité; public ArrayQueue() { objects = new Object[capacity]; } public ArrayQueue(int capacity) { this.capacity = capacity; objects = new Object[capacity]; } public Object dequeue() {if (isEmpty()) throw new NoSuchElementException("La file est vide"); Object object = objects[front++]; if (2*front>=capacity) // décaler vers la gauche { for (int i=0; i<size(); i++) objects[i] = objects[i+front]; back -= front; front = 0; } return object; } public Object enqueue(Object object) { if (back>=capacity) { Object[] temp = objects; capacity *= 2; // doubler la capacité objects = new Object[capacity]; for (int i=0; i
Implémentation contiguë
133
public Object getFront() {if (isEmpty()) throw new NoSuchElementException("La file est vide"); return objects[front]; } public Iterator iterator() { return new Iterator() // classe interne anonyme { private int cursor=front; public boolean hasNext() { return cursor=back) throw new NoSuchElementException(); return objects[cursor++]; } public void remove() { throw new UnsupportedOperationException(); } }; } public int size() { return back-front; } }
Le tableau objects est composé des éléments de la file. Comme l’indique le commentaire d’invariant de classe, seul le sous-tableau objects[front..(back-1)] est utilisé ; tous les autres éléments sont null. La classe contient deux constructeurs : le premier est un constructeur par défaut qui définit la capacité initiale du tableau à 16, tandis que le second laisse à l’utilisateur le soin de déterminer cette capacité initiale. Les méthodes getFront() et getBack() renvoient respectivement objects[front] et objects[back-1]. Quant à la méthode size(), elle renvoie back-front, soit le nombre d’éléments figurant dans le sous-tableau objects[front..(back-1)]. La méthode enqueue(Object) insère l’objet donné dans objects[back], puis elle incrémente l’index back. Si objects[back] n’existe pas, c’est-à-dire si back a atteint la fin du tableau, un nouveau tableau deux fois plus grand est créé avant l’insertion. Les éléments back-front sont ensuite copiés dans ce tableau, en commençant par l’index 0. La méthode dequeue() supprime l’objet situé au niveau de objects[front], puis incrémente l’index front. Suite à cette suppression, si l’index front se trouve dans la deuxième moitié finale du tableau (c’est-à-dire si au moins la moitié des éléments du tableau sont inutilisés), les éléments back-front sont tous décalés vers le début du tableau de façon à commencer au niveau de l’index 0. En dernier lieu, la méthode iterator() renvoie un itérateur qui vous permettra de parcourir la file. Étant donné que celle-ci est implémentée comme un sous-tableau, l’itérateur doit simplement suivre un index, nommé cursor, qui traverse ce sous-tableau. L’itérateur renvoyé est créé par le constructeur d’une classe interne anonyme qui définit les trois méthodes nécessaires à l’interface Iterator. Le curseur est initialisé au niveau de l’index front, puis il est incrémenté après chaque appel de la fonction next() qui renvoie objects[cursor]. Si la fonction next() est appelée alors que hasNext() est false (c’est-à-dire une fois que le curseur a atteint la fin de la file), une exception NoSuchElementException est lancée. La méthode remove() lance ensuite automatiquement une exception UnsupportedOperationException parce qu’une file interdit la suppression de ses éléments par une méthode autre que dequeue().
134
Files
Exemple 7.5 Tester la classe ArrayQueue Le pilote test suivant nous permettra d’implémenter notre file : public class TestQueue { public static void main(String[] args) { ArrayQueue q = new ArrayQueue(); System.out.println(q); q.enqueue("Amin"); System.out.println(q); q.enqueue("Bush"); System.out.println(q); q.enqueue("Chen"); System.out.println(q); q.enqueue("Diaz"); System.out.println(q); q.dequeue(); System.out.println(q); q.dequeue(); System.out.println(q); q.enqueue("Ford"); System.out.println(q); q.enqueue("Gore"); System.out.println(q); q.dequeue(); System.out.println(q); System.out.println("q.getFront() = " + q.getFront()); System.out.println("q.getBack() = " + q.getBack()); System.out.println("q.size() = " + q.size()); for (java.util.Iterator it=q.iterator(); it.hasNext(); ) System.out.println("\tit.next() = " + it.next()); for (;;) // forcer une exception { q.dequeue(); System.out.println(q); } } } [] [Amin] [Amin, Bush] [Amin, Bush, Chen] [Amin, Bush, Chen, Diaz] [Bush, Chen, Diaz] [Chen, Diaz] [Chen, Diaz, Ford] [Chen, Diaz, Ford, Gore] [Diaz, Ford, Gore] q.getFront() = Diaz q.getBack() = Gore q.size() = 3 it.next() = Diaz it.next() = Ford it.next() = Gore [Ford, Gore] [Gore] [] java.util.NoSuchElementException: la file est vide at LinkedQueue.dequeue(LinkedQueue.java:26) at TestQueue.main(TestQueue.java, Compiled Code) Exception in thread "main"
7.3 IMPLÉMENTATION CHAÎNÉE L’implémentation chaînée est très certainement plus efficace que l’implémentation contiguë parce qu’elle élimine principalement les risques de dépassement de capacité de la file. Cependant, étant donné que ce type d’implémentation a recours aux pointeurs, il reste plus complexe que l’implémentation contiguë.
Implémentation chaînée
135
Exemple 7.6 Classe LinkedQueue import java.util.*; import AbstractQueue; public class LinkedQueue extends AbstractQueue { private static class Node { Object object; Node next, previous; Node() { this.next = this.previous = this; } Node(Object object, Node next, Node previous) { this.object = object; this.next = next; this.previous = previous; } } private Node header = new Node(); private int size = 0; public Object dequeue() {if (isEmpty()) throw new NoSuchElementException("la file est vide"); Object object = header.next.object; header.next = header.next.next; header.next.previous = header; --size; return object; } public Object enqueue(Object object) { Node p = header.previous; // dernier élément de la file header.previous = p.next = new Node(object,header,p); ++size; return object; } public Object getBack() {if (isEmpty()) throw new NoSuchElementException("la file est vide"); return header.previous.object; } public Object getFront() {if (isEmpty()) throw new NoSuchElementException("la file est vide"); return header.next.object; } public Iterator iterator() { return new Iterator() // classe interne anonyme { private Node cursor=header; public boolean hasNext() { return cursor.next != header; } public Object next() { if (cursor.next==header) throw new NoSuchElementException(); cursor = cursor.next; return cursor.object; } public void remove() { throw new UnsupportedOperationException();
136
Files
} }; } public LinkedQueue() { } public int size() { return size; } }
7.4 APPLICATIONS UTILISANT LES FILES Les files sont naturellement utilisées lorsque la fréquence des demandes utilisateur pour certains services risque de dépasser celle à laquelle ces services peuvent être effectués. Imaginez, par exemple, des voitures qui font la queue à un péage, comme illustré dans le diagramme composé de quatre voitures et de trois cabines de péage. La situation est similaire avec un réseau local sur lequel de nombreux ordinateurs partagent uniquement quelques imprimantes : les travaux d’impression s’accumulent parfois dans la file d’attente. Il en va de même aux caisses d’un supermarché ou bien chez le coiffeur.
Exemple 7.7 Simulation d’un système client/serveur Le programme suivant vous propose une simulation d’un système général client/serveur, les clients pouvant être des voitures, des travaux d’impression ou bien des personnes, et les serveurs respectivement des cabines de péage, des imprimantes ou bien des coiffeurs. L’exécution de cette simulation créerait la sortie suivante :
Le travail #1 arrive au temps 2 avec 7 pages. La file contient maintenant 1 travail : [#1(7)] L’imprimante A(89%,84%) commence le travail #1 au temps 2. La file est maintenant vide. Le travail #2 arrive au temps 10 avec 39 pages. La file contient maintenant 1 travail : [#2(39)] L’imprimante B(97%,91%) commence le travail #2 au temps 10. La file est maintenant vide. L’imprimante A(89%,84%) termine le travail #1 au temps 11. Le travail #3 arrive au temps 18 avec 36 pages. La file contient maintenant 1 travail : [#3(36)] L’imprimante A(89%,87%) commence le travail #3 au temps 18. La file est maintenant vide. Le travail #4 arrive au temps 44 avec 126 pages. La file contient maintenant 1 travail : [#4(126)] L’imprimante C(106%,102%) commence le travail #4 au temps 44. La file est maintenant vide. L’imprimante B(97%,91%) termine le travail #2 au temps 53.
Applications utilisant les files
137
L’imprimante A(89%,87%) termine le travail #3 au temps 60. Le travail #5 arrive au temps 78 avec 170 pages. La file contient maintenant 1 travail : [#5(170)] L’imprimante A(89%,92%) commence le travail #5 au temps 78. La file est maintenant vide. Le travail #6 arrive au temps 113 avec 172 pages. La file contient maintenant 1 travail : [#6(172)] L’imprimante B(97%,95%) commence le travail #6 au temps 113. La file est maintenant vide. Le travail #7 arrive au temps 121 avec 40 pages. La file contient maintenant 1 travail : [#7(40)] L’imprimante D(128%,124%) commence le travail #7 au temps 121. La file est maintenant vide. Le travail #8 arrive au temps 127 avec 30 pages. La file contient maintenant 1 travail : [#8(30)] Le travail #9 arrive au temps 136 avec 41 pages. La file contient maintenant 2 travaux : [#8(30), #9(41)] Le travail #10 arrive au temps 140 avec 20 pages. La file contient maintenant 3 travaux : [#8(30), #9(41), #10(20)] Le travail #11 arrive au temps 147 avec 31 pages. La file contient maintenant 4 travaux : [#8(30), #9(41), #10(20), ➥ #11(31)] L’imprimante D(128%,124%) termine le travail #7 au temps 154. L’imprimante D(128%,126%) commence le travail #8 au temps 155. La file contient maintenant 3 travaux : [#9(41), #10(20), #11(31)] Le travail #12 arrive au temps 160 avec 63 pages. La file contient maintenant 4 travaux : [#9(41), #10(20), #11(31), ➥ #12(63)] L’imprimante C(106%,102%) termine le travail #4 au temps 168. L’imprimante C(106%,104%) commence le travail #9 au temps 169. La file contient maintenant 3 travaux : [#10(20), #11(31), #12(63)] L’imprimante D(128%,126%) termine le travail #8 au temps 179. L’imprimante D(128%,118%) commence le travail #10 au temps 180. La file contient maintenant 2 travaux : [#11(31), #12(63)] L’imprimante D(128%,118%) termine le travail #10 au temps 197. L’imprimante D(128%,138%) commence le travail #11 au temps 198. La file contient maintenant 1 travail : [#12(63)] L’imprimante C(106%,104%) termine le travail #9 au temps 209. L’imprimante C(106%,96%) commence le travail #12 au temps 210. La file est maintenant vide.
Dans cet exemple, les travaux d’impression correspondent aux clients, et les imprimantes aux serveurs. Ce cas de figure est composé de quatre serveurs, à savoir les imprimantes A, B, C et D, chacune d’entre elles se caractérisant par une vitesse d’impression différente exprimée sous forme d’un pourcentage. Ainsi, l’imprimante A a une vitesse d’impression de 89 %, soit environ 0,89 page par seconde. En outre, chaque travail d’impression est associé à une vitesse d’impression. Ainsi, l’imprimante A présente une vitesse d’impression égale à 84 % pour le travail #1, soit 0,84 page par seconde. La rapidité d’une même imprimante varie d’un travail à l’autre pour des raisons diverses, notamment en fonction du trafic sur le réseau. Ainsi, l’imprimante B, dont la vitesse d’impression est en moyenne égale à 0,97 page par seconde, imprime 0,91 page par seconde pour le travail #2, et 0,95 page par seconde pour le travail #6. D’autre part, les travaux d’impression arrivent dans la file de façon aléatoire. Dans le cas présent, le travail #1 a été inséré au temps 2 (soit 2 secondes après l’heure de début), le travail #2 au temps 10 et le travail #3 au temps 18. Si les imprimantes sont encore occupées lorsqu’un nouveau travail arrive, celui-ci est intégré à la file d’attente. C’est ce qui se produit pour le travail #8 qui arrive au temps 127, au moment où les quatre
138
Files
imprimantes sont utilisées. Avant cela, il restait toujours au moins une imprimante disponible qui pouvait commencer l’impression du travail dès son arrivée : • • • • • • •
L’imprimante A commence l’impression du travail #1 dès son arrivée au temps 2. L’imprimante B commence l’impression du travail #2 dès son arrivée au temps 10. L’imprimante A commence l’impression du travail #3 dès son arrivée au temps 18. L’imprimante C commence l’impression du travail #4 dès son arrivée au temps 44. L’imprimante A commence l’impression du travail #5 dès son arrivée au temps 78. L’imprimante B commence l’impression du travail #6 dès son arrivée au temps 113. L’imprimante D commence l’impression du travail #7 dès son arrivée au temps 121.
Le travail #8 doit donc attendre 28 secondes avant que l’imprimante D commence son impression au temps 155. Il est placé dans la file d’attente, comme tous les autres travaux qui se présentent au cours de ces 28 secondes. C’est pourquoi notre file contient les travaux #8, #9, #10 et #11 au temps 155. Dans l’exemple de sortie que nous venons de voir, chaque travail d’impression est identifié par son numéro ID et par sa taille. Ainsi, #1(7) signifie que le travail #1 est composé de 7 pages à imprimer. De la même manière, #8(30) indique que 30 pages doivent être imprimées pour le travail #8. #12
#11
#10
#9
#8
#7
D #4
C
#1
A 0
#10
#11
#9
#2
B
#8
#12
#6
#3
#5
100
100
200
300
Pour qu’une simulation soit efficace, vous devez utiliser des nombres générés de façon aléatoire. Dans le cas présent, nous avons eu recours à trois générateurs de nombres aléatoires : le premier a généré les vitesses d’impression moyennes de chaque imprimante, le second la vitesse d’impression réelle de chaque travail imprimé par une imprimante donnée, et le troisième l’intervalle de temps qui sépare l’arrivée des travaux. Ces générateurs sont des instances de l’extension suivante de la classe java.util.Random : public class Random extends java.util.Random { private double mean; private double standardDeviation; public Random(double mean) { this.mean = mean; this.standardDeviation = mean; }
Applications utilisant les files
139
public Random(double mean, double standardDeviation) { this.mean = mean; this.standardDeviation = standardDeviation; } public double nextGaussian() { double x = super.nextGaussian(); // x = normal(0.0, 1.0) return x*standardDeviation + mean; } public double nextExponential() { return -mean*Math.log(1.0 - nextDouble()); } public int intNextExponential() { return (int)Math.ceil(nextExponential()); } }
La méthode nextGaussian() renvoie des nombres aléatoires qui sont traditionnellement affectés avec la moyenne et la déviation standard données. Elle appelle et remplace la méthode synonyme dans la classe java.util.Random, ce qui renvoie des nombres aléatoires normalement attribués avec une moyenne égale à 0.0 et une déviation standard de 1.0. La méthode nextExponential() renvoie des nombres aléatoires qui sont attribués de façon exponentielle avec la moyenne donnée. Vous obtenez ainsi une répartition juste des intervalles qui séparent les arrivées. Cette méthode permet également de générer la taille des travaux qui détermine la durée de l’impression. Chaque travail d’impression est une instance de la classe suivante : public class Client { private static final int MEAN_JOB_SIZE = 100; private static Random randomJobSize = new Random(MEAN_JOB_SIZE); private static int nextId = 0; private int id, jobSize; private Server server; public Client(int time) { id = ++nextId; jobSize = randomJobSize.intNextExponential(); print(id,time,jobSize); } public double getJobSize() { return jobSize; } public void beginService(Server server, int time) { this.server = server; printBegins(server,id,time); } public void endService(int time) { printEnds(server,id,time); server = null; } public String toString() { return "#" + id + "(" + (int)Math.round(jobSize) + ")"; } private static void print(int job, int time, double size) { System.out.println("Le travail #" + job + " arrive au temps " + time + " avec " + (int)Math.round(size) + " pages."); } private static void printBegins(Server server, int job, int time)
140
Files
{ System.out.println("L’imprimante " + server + " commence le travail #" + job + " au temps " + time + "."); } private static void printEnds(Server server, int job, int time) { System.out.println("L’imprimante " + server + " termine le travail #" + job + " au temps " + time + "."); } }
Le générateur de nombres aléatoires randomJobSize génère la taille des travaux affectée de façon exponentielle avec une moyenne de 100 pages. Il est déclaré comme étant statique parce qu’une seule instance est nécessaire à la création de toutes les tailles de travaux. De la même façon, static int nextId permet de générer les numéros d’identification de tous les travaux. Le constructeur utilise le compteur nextId pour définir l’id du travail, puis le générateur randomJobSize afin de définir jobSize. Il imprime ensuite une ligne de sortie annonçant que le travail est arrivé. La méthode beginService() affecte la référence server à l’imprimante qui l’a appelée, puis elle imprime une ligne de sortie indiquant que l’impression a commencé. De la même façon, la méthode endService() annule la référence server après avoir imprimé une ligne de sortie signalant que l’impression est terminée. Chaque imprimante est représentée par une instance de la classe suivante : public class Server { private static Random randomMeanServiceRate = new Random(1.00,0.20); private static char nextId = ’A’; private Random randomServiceRate; private char id; private double meanServiceRate, serviceRate; private Client client; private int timeServiceEnds; public Server() { id = (char)nextId++; meanServiceRate = randomMeanServiceRate.nextGaussian(); randomServiceRate = new Random(meanServiceRate,0.10); } public void beginServing(Client client, int time) { this.client = client; serviceRate = randomServiceRate.nextGaussian(); client.beginService(this,time); int serviceTime = (int)Math.ceil(client.getJobSize()/serviceRate); timeServiceEnds = time + serviceTime; } public void endServing(int time) { client.endService(time); this.client = null; } public int getTimeServiceEnds() { return timeServiceEnds; } public boolean isFree() { return client == null; } public String toString() { int percentMeanServiceRate = (int)Math.round(100*meanServiceRate);
Applications utilisant les files
141
int percentServiceRate = (int)Math.round(100*serviceRate); return id + "(" + percentMeanServiceRate + "%," + percentServiceRate + "%)"; } }
Le générateur de nombres aléatoires randomMeanServiceRate génère normalement les vitesses avec une moyenne de 100.0 et une déviation standard de 20.0. Il crée la vitesse meanServiceRate pour chaque imprimante soit, dans notre exemple, une vitesse d’impression de 89 % pour l’imprimante A, de 97 % pour l’imprimante B, de 106 % pour l’imprimante C et de 128 % pour l’imprimante D. De la même façon, le générateur de nombres aléatoires randomServiceRate génère normalement les vitesses d’impression de chaque travail soit, dans notre exemple, 84 % pour le travail #1, 87 % pour le travail #3 et 92 % pour le travail #5. Ces vitesses ont été calculées à partir d’une affectation normale définie en fonction d’une moyenne égale à 89 % (pour l’imprimante A). La déviation standard est fixée à 10 % pour la répartition de chaque imprimante. La méthode beginServing() affecte la référence client au travail client en cours d’impression. Elle obtient la vitesse serviceRate extraite du générateur randomServiceRate, puis elle envoie le message beginService au travail d’impression client. Ensuite, l’affectation int serviceTime = (int)Math.ceil(client.getJobSize()/serviceRate); calcule la durée d’impression du travail (exprimée en secondes) en divisant la taille de ce travail (soit le nombre de pages) par la vitesse d’impression (soit le nombre de pages par seconde). Le plafond entier de cette division est ensuite ajouté à l’heure courante de façon à initialiser le champ timeServiceEnds de l’objet Server. La classe Main est la suivante : public class ClientServerSimulation { private static final int NUMBER_OF_SERVERS = 4; private static final double MEAN_INTERARRIVAL_TIME = 20.0; private static final int DURATION = 100; private static Server[] servers = new Server[NUMBER_OF_SERVERS]; private static Queue clients = new ArrayQueue(); private static Random random = new Random(MEAN_INTERARRIVAL_TIME); public static void main(String[] args) { for (int i=0; i
142
Files
else System.out.println("La file contient maintenant " + size + "job" + (size>1?"s: ":": ") + queue); }
La simulation de l’exemple 7.7 est qualifiée de simulation en temps réel parce que sa boucle principale est effectuée une fois pour chaque mouvement de l’horloge. Par opposition, une simulation événementielle a lieu lorsque la boucle principale est effectuée une fois pour chaque événement : à l’arrivée du travail, au début ou à la fin du service. Les simulations événementielles sont généralement plus simples, même si tous les serveurs doivent alors obligatoirement travailler à la même vitesse.
?
QUESTIONS DE RÉVISION
QUESTIONS DE RÉVISION
7.1 7.2
7.3
¿
Pourquoi les files sont-elles qualifiées de structures FIFO, c’est-à-dire Premier entré, premier sorti ? Peut-on qualifier les files de structures : a. LILO b. FILO Quels sont les avantages et les inconvénients de l’implémentation chaînée d’une file par rapport à une implémentation contiguë ?
RÉPONSES
RÉPONSES
7.1
Les files sont qualifiées de structures FIFO parce que le premier élément inséré dans une file est toujours le premier à en être supprimé.
7.2
a. Une file peut être une structure LILO (Last-In-Last-Out, Dernier entré, dernier sorti), c’est-àdire la même chose que le protocole Premier entré, premier sorti. b. Une file ne peut pas être une structure FILO (First-In-Last Out, Premier entré, dernier sorti) qui est le contraire du protocole Premier entré, premier sorti. L’implémentation chaînée présente l’avantage d’éliminer principalement les risques de dépassement de capacité de la file. En effet, le nombre d’appels de la méthode enqueue() est uniquement limité par la quantité de mémoire disponible pour l’opérateur new. En revanche, elle utilise des pointeurs qui la rendent plus complexe que l’implémentation contiguë.
7.3
?
EXERCICES D’ENTRAÎNEMENT
EXERCICES D’ENTRAÎNEMENT
7.1
Tracez le code suivant en indiquant le contenu de la file q après chaque appel : • ArrayQueue q; • q.enqueue("A"); • q.enqueue("B"); • q.enqueue("C"); • q.dequeue(); • q.dequeue();
Révision et entraînement
143
• q.enqueue("D"); • q.enqueue("E"); • q.enqueue("F"); • q.dequeue(); • q.enqueue("G"); • q.dequeue(); • q.dequeue(); • q.dequeue();
Implémentez la méthode des exercices 7.2 à 7.7 en utilisant uniquement le constructeur et les méthodes enqueue(), dequeue() et isEmpty() de la classe ArrayQueue : 7.2
• public static void reverse(ArrayQueue queue) • // inverse le contenu de la file donnée;
7.3
• private static ArrayQueue reversed(ArrayQueue queue); • // renvoie une nouvelle file qui contient les mêmes éléments • // que la file donnée, mais dans l’ordre inverse
7.4
• public static Object second(ArrayQueue queue) • // renvoie le deuxième élément à partir de la tête de file
7.5
• public static Object last(); • // renvoie le dernier élément de la file
7.6
• public static Object removeLast(); • // supprime et renvoie le dernier élément de la file
7.7
• public static ArrayQueue merge(ArrayQueue q1, ArrayQueue q2); • // fusionne les deux files données en les alternant • // tant que cela est possible, et renvoie la file combinée obtenue
7.8
Modifiez le programme de l’exemple 7.7 pour qu’il calcule et imprime les statistiques suivantes : a. le nombre moyen de travaux dans le système ; b. le nombre moyen de travaux dans la file ; c. la durée moyenne de présence d’un travail dans le système ; d. la durée moyenne d’attente d’un travail dans la file. Théoriquement, les réponses obtenues devraient être approximativement égales à ces résultats suivants : a. L = n/(st – n) b. (nL)/(st) c. tL d. (nL)/s avec n = taille moyenne du travail, s = nombre de serveurs et t = intervalle moyen entre les arrivées. Par exemple, si n = 100, s = 6 et t = 20, les réponses obtenues seront approximativement égales à : a. 5 travaux dans le système ; b. 4,17 travaux dans la file ; c. 100 secondes dans le système ; d. 83,3 secondes dans la file. Modifiez le programme de l’exercice 7.8 de façon à ce qu’il calcule et imprime également les statistiques suivantes : a. la durée de service moyenne de chaque serveur ; b. la durée de service moyenne de tous les travaux ; c. le pourcentage d’inactivité de chaque serveur.
7.9
144
Files
¿
SOLUTIONS
SOLUTIONS
7.1
La trace est la suivante :
A
7.2
q.enqueue('A')
A
q.enqueue('B')
A B
q.enqueue('C')
A B C
q.dequeue()
B C
q.dequeue()
C
q.enqueue('D')
C D
q.enqueue('E')
C D E
q.enqueue('F')
C D E F
q.dequeue()
D E F
q.enqueue('G')
D E F G
q.dequeue()
E F G
q.dequeue()
F G
q.dequeue()
G
La méthode suivante inverse le contenu de la file : • private static void reverse(ArrayQueue queue) • { Stack tempStack = new Stack(); • while(!queue.isEmpty()) • tempStack.push(queue.dequeue()); • while(!tempStack.empty()) • queue.enqueue(tempStack.pop()); •}
7.3
La méthode suivante renvoie le contenu inversé d’une file : • private static ArrayQueue reversed(ArrayQueue queue) • { ArrayQueue newQueue = new ArrayQueue(); • Stack stack = new Stack(); • while(!queue.isEmpty()) • { Object x = queue.dequeue(); • stack.push(x); • newQueue.enqueue(x); • } • while(!newQueue.isEmpty()) • queue.enqueue(newQueue.dequeue()); • while(!stack.empty())
Révision et entraînement • newQueue.enqueue(stack.pop()); • return newQueue; •}
7.4
La méthode suivante renvoie le deuxième élément à partir de la tête de file : • private static Object second(ArrayQueue queue) • { ArrayQueue tempQueue = new ArrayQueue(); • Object x = queue.dequeue(); • tempQueue.enqueue(x); • x = queue.dequeue(); • tempQueue.enqueue(x); • while(!queue.isEmpty()) • tempQueue.enqueue(queue.dequeue()); • while(!tempQueue.isEmpty()) • queue.enqueue(tempQueue.dequeue()); • return x; •}
7.5
La méthode suivante renvoie le dernier élément d’une file : • private static Object last(ArrayQueue queue) • { ArrayQueue tempQueue = new ArrayQueue(); • while(!queue.isEmpty()) • tempQueue.enqueue(queue.dequeue()); • Object x = null; • while(!tempQueue.isEmpty()) • { x = tempQueue.dequeue(); • queue.enqueue(x); • } • return x; •}
7.6
La méthode suivante supprime et renvoie le dernier élément d’une file : • private static Object removeLast(ArrayQueue queue) • { ArrayQueue tempQueue = new ArrayQueue(); • int count=0; • while(!queue.isEmpty()) • { tempQueue.enqueue(queue.dequeue()); • ++count; • } • Object x = null; • for (int i=0; i
7.7
La méthode suivante fusionne deux files : • public static ArrayQueue merged(ArrayQueue q1, ArrayQueue q2) • { ArrayQueue newQueue = new ArrayQueue(); • while(!q1.isEmpty() && !q2.isEmpty()) • { newQueue.enqueue(q1.dequeue()); • newQueue.enqueue(q2.dequeue()); • } • while(!q1.isEmpty()) • newQueue.enqueue(q1.dequeue()); • while(!q2.isEmpty()) • newQueue.enqueue(q2.dequeue()); • return newQueue; •}
145
146 7.8
Files
Le programme de l’exemple 7.7 peut être modifié de la façon suivante : Ajoutez tout d’abord ce code à la classe Client : • private int id, jobSize, tArrived, tBegan, tEnded; • • public Client(int time) • { id = ++nextId; • jobSize = randomJobSize.intNextExponential(); • tArrived = time; •} • • public double getJobSize() • { return jobSize; •} • • public int getWaitTime() • { return tBegan - tArrived; •} • • public int getServiceTime() • { return tEnded - tBegan; •} • • public void beginService(Server server, int time) • { this.server = server; • tBegan = time; •} • • public void endService(int time) • { tEnded = time; • server = null; •}
Ajoutez ensuite ce code à la classe Server : • public Client getClient() • { return client; •}
En dernier lieu, ajoutez ce code à la classe main : • private static int totalTime, queueTime, totalNumberOfJobs; • private static int[] numberOfJobs = new int[NUMBER_OF_SERVERS]; • public static void main(String[] args) • { for (int i=0; i
Révision et entraînement
147
• if (t == server.getTimeServiceEnds()) • { Client client = server.getClient(); • server.endServing(t); • int waitTime = client.getWaitTime(); • ++numberOfJobs[i]; // compter uniquement les • // projets terminés • } • } • } • totalTime += clients.size(); • queueTime += clients.size(); • } • for (int i=0; i
7.9
En ce qui concerne la seconde modification du programme de l’exemple 7.7, ajoutez le code suivant : • private static int totalTime, queueTime, totalNumberOfJobs, • totalServiceTime; • private static int[] serviceTime = new int[NUMBER_OF_SERVERS]; • private static int[] numberOfJobs = new int[NUMBER_OF_SERVERS]; • public static void main(String[] args) • { for (int i=0; i
148
Files • else // le serveur sert un client • { ++totalTime; // compter le temps dans le système • if (t == server.getTimeServiceEnds()) • { Client client = server.getClient(); • server.endServing(t); • int waitTime = client.getWaitTime(); • serviceTime[i] = client.getServiceTime(); • ++numberOfJobs[i]; // compter uniquement les • // travaux terminés • } • } • } • totalTime += clients.size(); • queueTime += clients.size(); • } • for (int i=0; i
Chapitre 8
Listes Une liste est un conteneur séquentiel capable d’insérer et de supprimer des éléments localement de façon constante, c’est-à-dire indépendamment de la taille du conteneur. Il est préférable d’utiliser cette structure de données pour les applications qui n’ont pas besoin d’un accès aléatoire. Pour comprendre de quoi il retourne, imaginez les wagons d’un train : pour en supprimer un, il suffit de le déconnecter des wagons le touchant, puis de reconnecter ces derniers entre eux. Dans le cadre de Java, l’interface List est une extension de l’interface Collection, c’est pourquoi elle fait partie, de même que son implémentation, du framework de collections Java 1.2 (reportez-vous à la section 5.1) défini dans le paquetage java.util. L’interface List fournit un type de données abstrait à la notion de séquence en termes mathématiques. Ainsi, les implémentations de List Java se comportent comme des conteneurs qui supportent un accès indexé à leurs éléments.
8.1 INTERFACE java.util.List L’interface List est définie de la façon suivante dans le paquetage java.util : public interface List extends Collection { public boolean add(Object object); public void add(int index, Object object); public boolean addAll(Collection collection); public boolean addAll(int index, Collection collection); public void clear(); public boolean contains(Object object); public boolean containsAll(Collection collection); public boolean equals(Object object); public Object get(int index); public int hashCode(); public int indexOf(Object object); public boolean isEmpty(); public Iterator iterator(); public int lastIndexOf(Object object); public ListIterator listIterator(); public ListIterator listIterator(int index); public Object remove(int index); public boolean remove(Object object); public boolean removeAll(Collection collection); public boolean retainAll(Collection collection);
150
Listes
public public public public public }
Object int List Object[] Object[]
set(int index, Object object); size(); subList(int start, int stop); toArray(); toArray(Object[] objects);
Vous remarquerez que ce code utilise un type d’itérateur spécial nommé ListIterator ; il s’agit d’un itérateur bidirectionnel.
Exemple 8.1 Utiliser l’interface List import java.util.*; public class Ex0801 { public static void main(String[] args) { String[] strings; strings = new String[]{"Adams","Tyler","Grant","Hayes","Nixon"}; List list = Arrays.asList(strings); System.out.println("list = " + list); System.out.println("list.size() = " + list.size()); System.out.println("list.getClass().getName() = " + list.getClass().getName()); System.out.println("list.get(1) = " + list.get(1)); System.out.println("list.contains(\"Tyler\") = " + list.contains("Tyler")); List sublist = list.subList(2,5); System.out.println("sublist = " + sublist); Object object = list.get(1); System.out.println("sublist.get(1) = " + sublist.get(1)); System.out.println("sublist.contains(\"Tyler\") = " + sublist.contains("Tyler")); list.remove(3); } } list = [Adams, Tyler, Grant, Hayes, Nixon] list.size() = 5 list.getClass().getName() = java.util.Arrays$ArrayList list.get(1) = Tyler list.contains("Tyler") = true sublist = [Grant, Hayes, Nixon] sublist.get(1) = Hayes sublist.contains("Tyler") = false Exception in thread "main" java.lang.UnsupportedOperationException at java.util.AbstractList.remove(AbstractList.java:174) at Testing.main(Testing.java:23)
Ce programme a recours à un tableau String pour construire l’objet List. La méthode getClass() indique que cet objet est une instance de la classe ArrayList. Les méthodes get()et sublist() utilisent les numéros d’index comme arguments. L’appel de list.sublist(2,5) renvoie un objet List qui contient les éléments des numéros 2 à 4 de la liste. L’appel list.remove(3) lance une exception UnsupportedOperationException parce que la classe ArrayList n’implémente pas la méthode remove(). L’exception lancée dans l’exemple 8.1 vous permet de constater que toutes les méthodes spécifiées dans l’interface List ne sont pas systématiquement implémentées. Lorsqu’elles ne le sont pas, elles doivent envoyer une exception UnsupportedOperationException.
151
Implémenter l’interface java.util.List
8.2 IMPLÉMENTER L’INTERFACE java.util.List Dans l’exemple 8.1, vous avez pu découvrir l’une des classes du framework de collections Java 1.2 qui implémente l’interface List : la classe ArrayList. Cette interface peut également être implémentée par les trois classes suivantes : AbstractList, LinkedList et Vector. Object AbstractCollection
Collection
AbstractList
List
AbstractSequentialList LinkedList Iterator
ArrayList Vector
ListIterator
La classe AbstractList joue, pour les listes, un rôle identique à celui de AbstractCollection pour les collections générales : étant une implémentation partielle de l’interface correspondante, elle limite la quantité de code nécessaire aux implémentations personnalisées. En outre, il est impossible de l’instancier directement parce qu’elle est définie comme abstraite. Nous reviendrons sur l’utilisation de cette classe dans la section 8.3. La classe LinkedList offre la structure et la fonctionnalité de toutes les classes de listes chaînées. Nous la détaillerons dans la section 8.6. La classe ArrayList implémente l’interface List à l’aide d’un tableau contigu. Nous l’aborderons plus en détail dans la section 8.5. Quant à la classe Vector, elle est similaire à la classe ArrayList, comme nous l’avons déjà vu dans la section 2.6.
8.3 CLASSES AbstractList ET Abstract-
SequentialList La classe AbstractList fournit l’ossature des implémentations complètes de la classe List qui ont recours à un tableau afin de stocker les éléments d’une liste. De la même façon, la classe AbstractSequentialList fournit l’ossature des implémentations complètes de la classe List qui ont recours à une structure chaînée non contiguë pour stocker les éléments d’une liste. Ces deux procédés de stockage sont fondamentalement opposés. En effet, la structure contiguë d’un tableau fournit un accès aléatoire immédiat, mais nécessite un certain nombre de transferts de données (insertions et suppressions), tandis que la structure chaînée est capable de gérer des insertions et des suppressions immédiates, ce qui signifie qu’elle ne permet pas l’utilisation des index et donc l’accès immédiat (accès aléatoire). Le tableau suivant résume les différences entre ces deux procédés :
Implémentation partielle
Implémentation complète
Structure de données
get(), set()
add(), remove()
AbstractList
ArrayList
tableau
O(1)
O(n)
AbstractSequentialList
LinkedList
liste chaînée
O(n)
O(1)
Si votre application requiert un accès rapide à une séquence statique, il est préférable d’utiliser la classe ArrayList, de l’étendre ou bien d’étendre sa classe parent AbstractList. En revanche, si votre applica-
tion requiert une séquence dynamique, c’est-à-dire avec des insertions et des suppressions fréquentes, pensez à utiliser la classe LinkedList, à l’étendre ou bien à étendre sa classe parent AbstractSequentialList.
152
Listes
Pour information, sachez que la classe LinkedList n’implémente pas la méthode get(int) directement. Vous trouverez ci-après une liste des méthodes de la classe AbstractList définies dans le paquetage java.util : public abstract class implements List { protected public boolean public void public boolean public boolean public void public boolean abstract public public int public int public Iterator public int public ListIterator public ListIterator public Object public void public Object public List }
AbstractList extends AbstractCollection AbstractList() add(Object object); add(int index, Object object); addAll(Collection collection); addAll(int index, Collection collection); clear(); equals(Object object); Object get(int index); hashCode(); indexOf(Object object); iterator(); lastIndexOf(Object object); listIterator(); listIterator(int index); remove(int index); removeRange(int start, int stop); set(int index, Object object); subList(int start, int stop);
La méthode get() étant déclarée comme abstraite, toutes les extensions concrètes de cette classe devront l’implémenter. L’implémentation des méthodes set(), add() et remove() est relativement aisée : { throw new UnsupportedOperationException(); }
Cette implémentation vous permet de comprendre pourquoi ces méthodes sont facultatives. En effet, elles peuvent éventuellement être remplacées par une extension selon l’efficacité de leur structure de données (reportez-vous au tableau de cette section). Une autre alternative est à votre disposition à ce stade : l’extension peut également laisser au moins l’une de ces implémentations. Dans ce cas, l’exception est lancée intentionnellement si une application utilise une méthode autre que celle qui lui était associée. Vous trouverez ci-après une liste des méthodes de la classe AbstractSequentialList définies dans le paquetage java.util : public abstract class AbstractSequentialList extends AbstractList { protected AbstractSequentialList() public void add(int index, Object object); public boolean addAll(Collection c); public boolean addAll(int index, Collection c); public Object get(int index); public Iterator iterator(); public int lastIndexOf(Object object); abstract public ListIterator listIterator(int index); public Object remove(int index); public Object set(int index, Object object); }
Les méthodes listIterator() et size() sont déclarées comme abstraites, c’est pourquoi chaque extension concrète de la classe devra les implémenter. N’oubliez pas que la méthode size() abstraite est héritée de la classe AbstractCollection (reportez-vous à la section 5.3).
Itérateurs de listes
153
8.4 ITÉRATEURS DE LISTES Un itérateur est un objet capable de se déplacer d’un élément à l’autre dans une collection. Il remplace l’indice des tableaux ou des vecteurs. De la même manière que vous utilisez naturellement les indices pour traiter les tableaux, vous utiliserez les itérateurs pour traiter les listes. Java 1.2 définit l’interface Iterator et la sous-interface ListIterator dans le paquetage java.util ; ces deux éléments font donc partie du framework de collections Java. L’interface Iterator spécifie le comportement d’un itérateur unidirectionnel dans une structure de données générale linéaire (reportez-vous à la section 5.5). En revanche, l’extension ListIterator spécifie le comportement d’un itérateur bidirectionnel dans une liste doublement chaînée. L’interface ListIterator, telle qu’elle est définie dans le paquetage java.util, est la suivante : public interface ListIterator extends Iterator { public void add(Object object); public boolean hasNext(); public boolean hasPrevious(); public Object next(); public int nextIndex(); public Object previous(); public int previousIndex(); public void remove(); public void set(Object object); }
Exemple 8.2 Utiliser un itérateur de liste import java.util.*; public class Ex0802 { public static void main(String[] args) { String[] planets = new String[]{"Neptune","Terre","Mars","Pluton"}; List list = Arrays.asList(planets); System.out.println("list = " + list); ListIterator it = list.listIterator(); System.out.println("it.next() = " + it.next()); System.out.println("it.next() = " + it.next()); System.out.println("it.next() = " + it.next()); System.out.println("it.next() = " + it.next()); System.out.println("it.previous() = " + it.previous()); System.out.println("it.previous() = " + it.previous()); it.add("Saturne"); } }
list = [Neptune, Terre, Mars, Pluton] it.next() = Neptune it.next() = Terre it.next() = Mars it.next() = Pluton it.previous() = Pluton it.previous() = Mars Exception in thread "main" java.lang.UnsupportedOperationException at java.util.AbstractList.add(AbstractList.java:153) at java.util.AbstractList$ListItr.add(AbstractList.java:503) at Testing.main(Testing.java:20)
154
Listes
Ce programme illustre le fonctionnement d’un itérateur bidirectionnel. Vous avez également pu constater que la méthode add() n’est pas implémentée pour les objets ListIterator qui itèrent sur les objets ArrayList. C’est pourquoi l’appel it.add("Saturne") déclenche le lancement de l’exception UnsupportedOperationException.
8.5 CLASSE ArrayList La classe ArrayList utilise un tableau pour implémenter la classe AbstractList. Elle est définie de la façon suivante dans le paquetage java.util : public class ArrayList extends AbstractList implements List { public boolean add(Object object) public void add(int index, Object object) public boolean addAll(Collection collection) public boolean addAll(int index, Collection collection) public ArrayList() public ArrayList(int initialCapacity) public ArrayList(Collection collection) public void clear() public Object clone() public boolean contains(Object object) public void ensureCapacity(int capacity) public Object get(int index) public int indexOf(Object object) public boolean isEmpty() public int lastIndexOf(Object object) public Object remove(int index) public Object set(int index, Object object) public int size() public Object[] toArray() public Object[] toArray(Object[] objects) public void trimToSize() }
Les deux méthodes ensureCapacity(int) et trimToSize() gèrent plus spécifiquement la capacité privée d’un objet ArrayList. L’entier obtenu correspond à la taille réelle du tableau qui stocke les éléments de l’objet ArrayList. Sur les 21 méthodes implémentées par cette classe, seules deux, ainsi que les constructeurs, ne constituent pas une personnalisation de la méthode correspondante dans l’une des classes ancêtres AbstractList, AbstractCollection ou Object.
Exemple 8.3 Utiliser ArrayList pour stocker les données classées Le fichier texte suivant nommé Villes.txt liste les neuf villes les plus importantes en 1990, par ordre décroissant de leur nombre d’habitants (Tokyo étant donc la ville la plus peuplée). Le programme qui suit est destiné à lire ces données dans ArrayList, puis à utiliser les méthodes indexOf(), remove() et add() afin de mettre à jour les données pour l’année 1995. import java.io.*; import java.util.*; public class Ex0803 { private static ArrayList list = new ArrayList(); public static void main(String[] args) { load("Villes.txt"); System.out.println(list); list.remove(list.indexOf("Seoul"));
Villes.txt
Tokyo Mexico Sao Paolo Seoul New York Osaka Bombay
Classe LinkedList
155
list.remove(list.indexOf("Osaka")); list.add(5,"Shanghai"); list.add(6,"Los Angeles"); System.out.println(list); } private static void load(String filename) { try { File file = new File(filename); FileReader reader = new FileReader(file); BufferedReader in = new BufferedReader(reader); String ville = in.readLine(); while (ville != null) { list.add(ville); ville = in.readLine(); } } catch(Exception e) { System.out.println(e); } } } [Tokyo, Mexico, Sao Paolo, Seoul, New York, Osaka, Bombay, ➥ Calcutta, Buenos Aires] [Tokyo, Mexico, Sao Paolo, New York, Bombay, Shanghai, Los Angeles, ➥ Calcutta, Buenos Aires]
8.6 CLASSE LinkedList La classe LinkedList utilise une liste chaînée afin d’implémenter la classe AbstractSequentialList. Elle est définie de la façon suivante dans le paquetage java.util : public class LinkedList extends AbstractSequentialList implements List { public boolean add(Object object) public void add(int index, Object object) public boolean addAll(Collection collection) public boolean addAll(int index, Collection collection) public void addFirst(Object object) public void addLast(Object object) public void clear() public Object clone() public boolean contains(Object object) public Object getFirst() public Object getLast() public int indexOf(Object object) public int lastIndexOf(Object object) public LinkedList() public LinkedList(Collection collection) public ListIterator listIterator(int index) public Object remove(int index) public boolean remove(Object object) public Object removeFirst() public Object removeLast() public Object set(int index, Object object) public int size() public Object[] toArray() public Object[] toArray(Object[] objects) }
156
Listes
Parmi les 24 méthodes définies dans la classe LinkedList, seules les neuf qui apparaissent ici en gras ne sont pas des redéfinitions de la méthode correspondante dans l’une des classes ancêtres AbstractSequentialList, AbstractList, AbstractCollection ou Object.
Exemple 8.4 Classe Ring Le programme suivant permet de définir une classe destinée aux listes circulaires doublement liées. Cette classe est similaire à java.util.LinkedList, à l’exception du fait que les méthodes next() et previous() sont capables de passer d’un bout à l’autre de la liste en cercle. package schaums.dswj; import java.util.*; public class Ring extends java.util.AbstractSequentialList { private Node header; private int size = 0; public Ring() { } public Ring(List list) { super(); addAll(list); } public ListIterator listIterator(int index) { return new RingIterator(index); } public int size() { return size; } private static class Node { Object object; Node previous, next; Node(Object object, Node previous, Node next) { this.object = object; this.previous = previous; this.next = next; } Node(Object object) { this.object = object; this.previous = this.next = this; } } private class RingIterator implements ListIterator { private Node next, lastReturned; private int nextIndex; RingIterator(int index) { if (index<0 || index>size) throw new IndexOutOfBoundsException("Index : " + index); next=(size==0?null:header); for (nextIndex=0; nextIndex
Classe LinkedList
public boolean hasNext() { return size > 0; } public boolean hasPrevious() { return size > 0; } public Object next() { if (size==0) throw new NoSuchElementException(); lastReturned = next; next = next.next; nextIndex = (nextIndex==size-1?0:nextIndex+1); return lastReturned.object; } public Object previous() { if (size==0) throw new NoSuchElementException(); next = lastReturned = next.previous; nextIndex = (nextIndex==0?size-1:nextIndex-1); return lastReturned.object; } public int nextIndex() { return nextIndex; } public int previousIndex() { return (nextIndex==0?size-1:nextIndex-1); } public void add(Object object) { if (size==0) { next = header = new Node(object); nextIndex = 0; } else { Node newNode = new Node(object,next.previous,next); newNode.previous.next = next.previous = newNode; } lastReturned = null; ++size; nextIndex = (nextIndex==size-1?0:nextIndex+1); } public void remove() { if (lastReturned==null) throw new IllegalStateException(); if (next==lastReturned) next = lastReturned.next; else nextIndex = (nextIndex==0?size-1:nextIndex-1); lastReturned.previous.next = lastReturned.next; lastReturned.next.previous = lastReturned.previous; lastReturned = null; --size; } public void set(Object object) { if (lastReturned==null) throw new IllegalStateException(); lastReturned.object = object; } }
157
158
Listes
Étant une sous-classe de la classe AbstractSequentialList, cette classe Ring doit obligatoirement implémenter les méthodes listIterator(int) et size(). En outre, puisque la méthode listIterator(int) doit renvoyer un objet ListIterator, notre classe doit également implémenter les neuf méthodes de l’interface (reportez-vous à la section 8.4) grâce à la classe interne RingIterator. La classe Ring définit deux champs privés (header et size), quatre méthodes size 8 publiques et deux classes privées (Node et RingIterator). header Une liste chaînée est une séquence de nœuds chaînés, c’est-à-dire d’objets distincts Ring qui contiennent les données de la liste, à raison d’un composant par nœud. C’est la raison pour laquelle toute implémentation d’une liste chaînée requiert l’utilisation d’une classe Node interne avec un champ destiné aux données et un autre destiné au chaînage. Dans le cas de notre implémentation, le champ de données du nœud est une réféprevious rence Object nommée object. Étant donné que ces listes seront doublement object 'B' chaînées, la classe Node est composée de deux champs de chaînage nommés prenext vious et next. Quelle que soit la structure chaînée utilisée (une liste, un arbre, un Node graphe, etc.), chaque champ doit être une référence au même type que la classe de nœud elle-même. Ainsi, dans cette implémentation, previous et next sont des références à Node. Le champ header de la classe Ring pointe vers le premier nœud de la liste. Vous remarquerez que cette implémentation n’utilise aucun nœud d’en-tête factice. C’est pourquoi le nombre de nœuds est toujours égal au nombre réel de composants de la liste stocké dans le champ size de cette classe. La classe interne RingIterator implémente l’interface java.util.Linnext kedList. Elle est composée de trois champs : next et lastReturned, qui lastReturned sont des références aux nœuds de listes, et l’entier nextIndex, qui assure le nextIndex 5 suivi du numéro d’index du nœud recherché par l’itérateur. Le champ next RingIterator pointe vers le nœud suivant de la liste, soit le prochain à être consulté si l’itérateur est avancé. Le champ lastReturned pointe vers le nœud qui a été renvoyé par l’appel précédent de la méthode next() ou previous(). Il recherche le nœud concerné par un appel de la méthode remove() ou set(). L’interface ListIterator spécifie si les méthodes hasNext() et hasPrevious() devraient renvoyer true lorsque la liste contient plus de composants dans la direction correspondante. En ce qui concerne la classe Ring, qui n’a ni début, ni fin, ces deux méthodes renverront toujours true, sauf si la liste est vide. Les méthodes next() et previous() avancent l’itérateur jusqu’au nœud suivant dans la direction indiquée. L’instruction next = next.next; est utilisée lorsqu’il s’agit d’avancer. Vous la comprendrez mieux si vous pensez qu’une référence à un objet est en fait l’adresse de cet objet dans la mémoire principale. Ainsi, cette instruction affecte l’adresse stockée dans next.next à la variable de référence next. Le diagramme suivant illustre l’exemple de 12 objets et de leur adresse mémoire réelle au cours de l’exécution du pilote test de l’exemple 8.5. 0x15c6d50
size 8 header 0x15c8298
0x15c8290
value 'B' Character
0x15c8540
value 'C' Character
0x15c8530
value 'D' Character
Ring 0x15c8298
previous object next
0x15c84e8 0x15c8820 0x15c8288
Node 0x15c8820
value 'A' Character
0x15c8288
previous object next
0x15c8298 0x15c8290 0x15c8538
Node 0x15c8640
next 0x15c8538 lastReturned 0x15c8288 nextIndex 2 RingIterator
0x15c8538
previous object next
0x15c8288 0x15c8540 0x15c8528
Node
0x15c8528
previous object next
0x15c8538 0x15c8530 0x15c8518
Node
159
Classe LinkedList
Dans le cas présent, l’adresse stockée dans next.next est 0x15c8528, et celle stockée dans next est 0x15c8538. Ainsi, l’affectation next = next.next; a modifié la valeur de la référence next de 0x15c8538 en 0x15c8528. En d’autres termes, le champ next de l’itérateur ne recherche plus le troisième nœud, mais le quatrième. Vous remarquerez que cette représentation des objets est plus simple que la suivante, dans laquelle chaque référence d’objet (adresse mémoire) est symbolisée par une flèche pointant vers le référent : size
8
header
value 'C'
value 'B' Character
Character
value 'D' Character
Ring
previous
previous
previous
previous
object
object
object
object
next
next
next
next
Node
value 'A' Character
Node
Node
Node
next lastReturned nextIndex
2
RingIterator
Prêtez attention à l’utilisation de l’opérateur d’expression conditionnelle pour incrémenter et de décrémenter le champ nextIndex, respectivement dans les méthodes next() et previous(). Par exemple, l’expression nextIndex = (nextIndex==size-1?0:nextIndex+1); attribue la valeur 0 au champ ou bien elle l’incrémente selon la valeur de sa taille. Lorsque celle-ci est égale à size-1, c’est que l’itérateur se trouve au niveau du dernier élément de la liste et qu’il devra passer au premier élément si vous l’avancez, c’est-à-dire à l’élément dont l’index est 0. Dans le cas contraire, le champ sera simplement incrémenté. Les méthodes nextIndex() et previousIndex() renvoient respectivement le dernier élément et l’élément précédent. Ce dernier élément est stocké dans le champ nextIndex de l’itérateur. L’élément précédent doit lui être inférieur de 1, sauf si la valeur de nextIndex est égale à 0, auquel cas l’index précédent doit être égal à size-1. Voilà qui illustre parfaitement le fait qu’une liste circulaire chaînée soit consultée en boucle. La méthode add() insère l’objet donné comme nouveau composant de la liste. Le diagramme suivant illustre le fonctionnement de ce code : Node newNode = new Node(object,next.previous,next); newNode.previous.next = next.previous = newNode;
Les pointeurs qui seront amenés à changer sont signalés en pointillés. Remarquez comment le pointeur lastReturned est invalidé (c’est-à-dire devient null) après l’insertion. Cela vous indique que la dernière opération effectuée par l’itérateur n’était pas un appel de next(), ni de previous(). En outre, vous pouvez en déduire que, ni la méthode add(), ni la méthode remove() ne peuvent être appelées si vous n’avez pas d’abord appelé une nouvelle fois la méthode next() ou previous(). Si vous oubliez cette étape, une exception UnsupportedOperationException sera lancée, comme nous l’avons déjà vu dans l’exemple 8.2.
160
Listes
Avant : previous object 'X' next Node
previous
previous
object 'C'
object 'D' next
next Node
Node
next lastReturned nextIndex
4
RingIterator
Après : previous object 'X' next Node
previous
previous
object 'C'
object 'D'
next Node
next lastReturned nextIndex
4
RingIterator
Exemple 8.5 Tester la classe Ring import java.util.*; import schaums.dswj.Ring; public class Ex0808 { private static final int SIZE=8; private static Ring ring = new Ring(); public static void main(String[] args) { ListIterator it = ring.listIterator(); for (int n=0; n<SIZE; n++) it.add(new Character((char)(’A’+n))); System.out.println(ring); it = ring.listIterator(); // l’initialiser à nouveau printNext(it,10); printPrevious(it,4);
next Node
161
Classe LinkedList
System.out.println(ring); it = ring.listIterator(); // l’initialiser à nouveau printNext(it,2); it.remove(); System.out.println(ring); printNext(it,3); it.remove(); System.out.println(ring); printPrevious(it,2); it.remove(); System.out.println(ring); printPrevious(it,3); it.remove(); System.out.println(ring); } private static void printNext(ListIterator it, int n) { for (int i=0; i
G, H] it.next() = A it.next() = B it.next() = C it.next() = D it.next() = E it.next() = F it.next() = G it.next() = H it.next() = A it.next() = B = 1 it.previous() = 0 it.previous() = 7 it.previous() = 6 it.previous() G, H] it.next() = A it.next() = B H] it.next() = C it.next() = D it.next() = E
= = = =
B A H G
= 2 it.previous() = D = 1 it.previous() = C = 0 it.previous() = A = 4 it.previous() = H = 3 it.previous() = G
Afin de vous faciliter la tâche, ce programme utilise deux méthodes d’impression : d’une part, printNext() appelle un nombre de fois donné nextIndex() et next(), et d’autre part, printPrevious() effectue la même opération pour previousIndex() et previous().
162
Listes
Tout d’abord, ce programme charge l’anneau à l’aide de huit objets Character :
ring
size
7
header Ring
B
H
A
G
C
F
D
next
E
it
lastReturned nextIndex
4
RingIterator
Il utilise ensuite ses méthodes d’impression afin de parcourir l’anneau dans le sens des aiguilles d’une montre et dans le sens inverse, ce qui