Chapitres 5 et 6 Les instructions de contrôle (I et II)

Sommaire Introduction Les expressions booléennes Les instructions de sélection Les instructions de répétition Comparaison de données La notion d’itérateurs La classe ArrayList

Objectifs Définition du flot de contrôle à travers une méthode Expressions booléennes et instructions if: prise de décision Comparaison de données Exécution répétitive d’instructions Utilisation d’itérateurs Introduction de la classe ArrayList

Introduction Les instructions au sein d’un programme sont exécutées selon un certain ordre - on parle de flot de contrôle Les instructions dans un programme Java sont exécutées de façon séquentielle, l’une à la suite de l’autre Pour s’affranchir de cette séquentialité et disposer de programmes puissants et intelligents, il serait intéressant d’effectuer des sélections et des répétitions Cette possibilité est basée sur l’utilisation des expressions booléennes Java dispose d’instructions structurées permettant d’effectuer: Des choix: if ... else et switch Des répétitions: do ... while, while, et for Des instructions de branchement conditionnel: break et continue

Les expressions booléennes Grâce aux différents types d’instructions, il est possible d’avoir plusieurs chemins d’exécution au sein d’un programme (plusieurs scénarios) Le passage par tel ou tel chemin est soumis à certaines conditions associées aux différentes instructions (données et traitements) Ces conditions utilisent souvent certains opérateurs, notamment les opérateurs logiques et les opérateurs relationnels Opérateurs relationnels: ( == (égal), != (différent), < (inférieur), > (supérieur), <=, >=) Opérateurs logiques: (!, &&, ||) Les opérandes dans le cas des opérateurs logiques sont de types boolean et le résultat est de type boolean ! est un opérateur unaire et les deux autres (&&, ||) sont des opérateurs binaires Exemples: !a, a && b, a || b

VOIR EX17 //******************************************************************** // Age.java Author: Lewis/Loftus // // Demonstrates the use of an if statement. import java.util.Scanner; public class Age { //----------------------------------------------------------------- // Reads the user's age and prints comments accordingly. public static void main(String[] args) final int MINOR = 21; Scanner scan = new Scanner(System.in); System.out.print("Enter your age: "); int age = scan.nextInt(); continue Copyright © 2017 Pearson Education, Inc.

System.out.println("You entered: " + age); if (age < MINOR) continue System.out.println("You entered: " + age); if (age < MINOR) System.out.println("Youth is a wonderful thing. Enjoy."); System.out.println("Age is a state of mind."); } Copyright © 2017 Pearson Education, Inc.

Sample Run Another Sample Run Enter your age: 47 You entered: 47 Age is a state of mind. continue System.out.println("You entered: " + age); if (age < MINOR) System.out.println("Youth is a wonderful thing. Enjoy."); System.out.println("Age is a state of mind."); } Another Sample Run Enter your age: 12 You entered: 12 Youth is a wonderful thing. Enjoy. Age is a state of mind. Copyright © 2017 Pearson Education, Inc.

Les expressions booléennes L’opérateur logique !, appelé également négation logique ou complément logique, est un opérateur ayant une priorité supérieure à celle de tous les opérateurs binaires arithmétiques et opérateurs relationnels L’opérateurs && et plus prioritaire que ||, et les deux sont moins prioritaires que les opérateurs arithmétiques et relationnels Exemple: a et !a (si a est vrai !a sera faux et si a est faux !a sera vrai) !(a==b) et !a==b (interprété !(a)==b) peuvent conduire à des résultats différents en raison de la priorité de ! Pour l’opérateur &&: le résultat sera vrai si les deux opérandes sont vraies et faux dans les autres cas Pour l’opérateur ||: le résultat est vrai si les deux opérandes ou l’un deux est vrai - faux sinon

Les expressions booléennes Différentes combinaisons a b a && b a || b true false Copyright © 2017 Pearson Education, Inc.

Les expressions booléennes Les différents résultats possibles pour l’expression suivante: (total < MAX+5 && !found) total < MAX found !found total < MAX && !found false true Copyright © 2017 Pearson Education, Inc.

Les expressions booléennes Les opérateurs && et || possèdent une propriété intéressante, leur second opérande n’est évalué que si sa valeur est nécessaire pour décider si la valeur de l’expression correspondante est vraie ou fausse On parle d’opérateurs court-circuit Exemple : (count!=0 && total/count>Max) // si count!=0 est faux, il est inutile d’évaluer // le reste a<b && c<d // si a<b est faux, il est inutile d’évaluer le reste

Les instructions de sélection: L’instruction If Syntaxe: If (condition) instruction1 [else instruction2] Condition: est une expression booléenne quelconque instruction1 et instruction2: sont des instructions quelconques (simple, structurées ou bloc d’instructions) Un bloc d’instructions est un ensemble d’instructions quelconques délimitées par deux accolades {} Les crochets []: spécifient que ce qu’ils englobent est facultatif – peut exister ou non Sémantique: si la condition est vraie l’instruction instruction1 est exécutée, dans le cas contraire c’est l’instruction instruction2 qui le sera si [else … instruction2] existe Indentation: une indentation soignée permet une meilleure lisibilité et donc une meilleure compréhension du programme – l’indentation est ignorée par le compilateur Attention : //delta ne fait pas partie du bloc else malgré l’indentation if (depth >= UPPER_LIMIT) delta = 100; else System.out.println("Reseting Delta"); delta = 0;

VOIR EX18 //******************************************************************** // Wages.java Author: Lewis/Loftus // // Demonstrates the use of an if-else statement. import java.text.NumberFormat; import java.util.Scanner; public class Wages { //----------------------------------------------------------------- // Reads the number of hours worked and calculates wages. public static void main(String[] args) final double RATE = 8.25; // regular pay rate final int STANDARD = 40; // standard hours in a work week Scanner scan = new Scanner(System.in); double pay = 0.0; continue Copyright © 2017 Pearson Education, Inc.

System.out.print("Enter the number of hours worked: "); continue System.out.print("Enter the number of hours worked: "); int hours = scan.nextInt(); System.out.println(); // Pay overtime at "time and a half" if (hours > STANDARD) pay = STANDARD * RATE + (hours-STANDARD) * (RATE * 1.5); else pay = hours * RATE; NumberFormat fmt = NumberFormat.getCurrencyInstance(); System.out.println("Gross earnings: " + fmt.format(pay)); } Copyright © 2017 Pearson Education, Inc.

Sample Run Enter the number of hours worked: 46 Gross earnings: $404.25 continue System.out.print("Enter the number of hours worked: "); int hours = scan.nextInt(); System.out.println(); // Pay overtime at "time and a half" if (hours > STANDARD) pay = STANDARD * RATE + (hours-STANDARD) * (RATE * 1.5); else pay = hours * RATE; NumberFormat fmt = NumberFormat.getCurrencyInstance(); System.out.println("Gross earnings: " + fmt.format(pay)); } Copyright © 2017 Pearson Education, Inc.

VOIR EX19 //******************************************************************** // CoinFlip.java Author: Lewis/Loftus // // Demonstrates the use of an if-else statement. public class CoinFlip { //----------------------------------------------------------------- // Creates a Coin object, flips it, and prints the results. public static void main(String[] args) Coin myCoin = new Coin(); myCoin.flip(); System.out.println(myCoin); if (myCoin.isHeads()) System.out.println("You win."); else System.out.println("Better luck next time."); } Copyright © 2017 Pearson Education, Inc.

//******************************************************************** // Coin.java Author: Lewis/Loftus // // Represents a coin with two sides that can be flipped. public class Coin { private final int HEADS = 0; private final int TAILS = 1; private int face; //----------------------------------------------------------------- // Sets up the coin by flipping it initially. public Coin() flip(); } continue Copyright © 2017 Pearson Education, Inc.

//----------------------------------------------------------------- continue //----------------------------------------------------------------- // Flips the coin by randomly choosing a face value. public void flip() { face = (int) (Math.random() * 2); } // Returns true if the current face of the coin is heads. public boolean isHeads() return (face == HEADS); Copyright © 2017 Pearson Education, Inc.

//----------------------------------------------------------------- continue //----------------------------------------------------------------- // Returns the current face of the coin as a string. public String toString() { String faceName; if (face == HEADS) faceName = "Heads"; else faceName = "Tails"; return faceName; } Copyright © 2017 Pearson Education, Inc.

Sample Run Tails Better luck next time. //******************************************************************** // CoinFlip.java Author: Lewis/Loftus // // Demonstrates the use of an if-else statement. public class CoinFlip { //----------------------------------------------------------------- // Creates a Coin object, flips it, and prints the results. public static void main(String[] args) Coin myCoin = new Coin(); myCoin.flip(); System.out.println(myCoin); if (myCoin.isHeads()) System.out.println("You win."); else System.out.println("Better luck next time."); } Copyright © 2017 Pearson Education, Inc.

VOIR EX20 //******************************************************************** // Guessing.java Author: Lewis/Loftus // // Demonstrates the use of a block statement in an if-else. import java.util.*; public class Guessing { //----------------------------------------------------------------- // Plays a simple guessing game with the user. public static void main(String[] args) final int MAX = 10; int answer, guess; Scanner scan = new Scanner(System.in); Random generator = new Random(); answer = generator.nextInt(MAX) + 1; continue Copyright © 2017 Pearson Education, Inc.

System.out.print("I'm thinking of a number between 1 and " continue System.out.print("I'm thinking of a number between 1 and " + MAX + ". Guess what it is: "); guess = scan.nextInt(); if (guess == answer) System.out.println("You got it! Good guessing!"); else { System.out.println("That is not correct, sorry."); System.out.println("The number was " + answer); } Copyright © 2017 Pearson Education, Inc.

Sample Run I'm thinking of a number between 1 and 10. Guess what it is: 6 That is not correct, sorry. The number was 9 continue System.out.print("I'm thinking of a number between 1 and " + MAX + ". Guess what it is: "); guess = scan.nextInt(); if (guess == answer) System.out.println("You got it! Good guessing!"); else { System.out.println("That is not correct, sorry."); System.out.println("The number was " + answer); } Copyright © 2017 Pearson Education, Inc.

Les instructions de sélection: L’instruction If Imbrications des instructions if: Selon la syntaxe de l’instruction if, instruction1 et instruction2 peuvent être des instructions quelconques, entre autres, des instructions if – on parle dans ce cas d’instructions imbriquées Syntaxe de if: If (condition) instruction1 [else instruction2] Soit l’exemple suivant: If (condition1) if (condition2) else instruction2 Pour éviter toute confusion et ambiguïté (a quel if se rapporte le else) la règle adoptée est que le else se rapporte toujours au dernier if rencontré (auquel un else n’a pas été attribué)

VOIR EX21 //******************************************************************** // MinOfThree.java Author: Lewis/Loftus // // Demonstrates the use of nested if statements. import java.util.Scanner; public class MinOfThree { //----------------------------------------------------------------- // Reads three integers from the user and determines the smallest // value. public static void main(String[] args) int num1, num2, num3, min = 0; Scanner scan = new Scanner(System.in); System.out.println("Enter three integers: "); num1 = scan.nextInt(); num2 = scan.nextInt(); num3 = scan.nextInt(); continue Copyright © 2017 Pearson Education, Inc.

System.out.println("Minimum value: " + min); } continue if (num1 < num2) if (num1 < num3) min = num1; else min = num3; if (num2 < num3) min = num2; System.out.println("Minimum value: " + min); } Copyright © 2017 Pearson Education, Inc.

Sample Run Enter three integers: 84 69 90 Minimum value: 69 continue 84 69 90 Minimum value: 69 continue if (num1 < num2) if (num1 < num3) min = num1; else min = num3; if (num2 < num3) min = num2; System.out.println("Minimum value: " + min); } Copyright © 2017 Pearson Education, Inc.

Les instructions de sélection: Switch Syntaxe: switch (expression) { case constante-1 : [ suite d'instructions-1] case constante-2 : [ suite d'instructions-2] … case constante-n : [ suite d'instructions-n] [ default : suite d'instructions-m] }   expression: de type byte, ou short, ou char, ou bien int constante-i: expression constante de même type qu’expression (ou compatible) suite d'instructions : séquence d'instructions quelconques

Les instructions de sélection: Switch Fonctionnement: 1. On commence par évaluer l’expression figurant après le mot clé switch 2. Par la suite, on cherche dans le bloc qui suit s’il existe une étiquette (case constante-1) qui  correspond à la valeur obtenue 3. Si oui, on exécute le bloc d’instructions, dans le cas contraire on poursuit en séquence Le bloc default, s’il existe, sera exécuté dans le cas ou aucune des étiquettes des blocs précédents ne coïncide [ suite d'instructions-i] peut être suivie ou non par le mot clé break: 1. Le mot clé break existe: une fois le bloc instructions-i exécuté on passe à la prochaine instruction 2. Le mot clé break n’existe pas: on continue en séquence

VOIR EX22 //******************************************************************** // GradeReport.java Author: Lewis/Loftus // // Demonstrates the use of a switch statement. import java.util.Scanner; public class GradeReport { //----------------------------------------------------------------- // Reads a grade from the user and prints comments accordingly. public static void main(String[] args) int grade, category; Scanner scan = new Scanner(System.in); System.out.print("Enter a numeric grade (0 to 100): "); grade = scan.nextInt(); category = grade / 10; System.out.print("That grade is "); continue Copyright © 2017 Pearson Education, Inc.

System.out.println("a perfect score. Well done."); break; case 9: continue switch (category) { case 10: System.out.println("a perfect score. Well done."); break; case 9: System.out.println("well above average. Excellent."); case 8: System.out.println("above average. Nice job."); case 7: System.out.println("average."); case 6: System.out.println("below average. You should see the"); System.out.println("instructor to clarify the material " + "presented in class."); default: System.out.println("not passing."); } Copyright © 2017 Pearson Education, Inc.

Sample Run Enter a numeric grade (0 to 100): 91 That grade is well above average. Excellent. continue switch (category) { case 10: System.out.println("a perfect score. Well done."); break; case 9: System.out.println("well above average. Excellent."); case 8: System.out.println("above average. Nice job."); case 7: System.out.println("average."); case 6: System.out.println("below average. You should see the"); System.out.println("instructor to clarify the material " + "presented in class."); default: System.out.println("not passing."); } Copyright © 2017 Pearson Education, Inc.

Comparaison de données Dans une expression booléenne, différents types de données peuvent être utilisés (entier, réels, caractères, chaîne de caractères, et objet) Comparaison des flottants (Doubles) (approximation des nombres réels) Deux réels sont égaux si leurs représentations binaires sont égales - on ne peut donc pas utiliser l’opérateur ‘==‘ Pour comparer deux réels, on utilise la technique suivante: If (Math.abs(f1-f2)< TOLERANCE) // Tolerance possède une valeur appropriée – ex: 0.000001 System.out. Println (¨égale¨); // f1 et f2 sont deux flottants

Comparaison de données Comparaison de caractères En Java, les caractères sont basés sur le code universel unicode Grâce à ce code, chaque caractère est représenté par une valeur numérique ordonnée On peut donc les comparer en utilisant les opérateurs relationnels Characters Unicode Values 0 – 9 48 through 57 A – Z 65 through 90 a – z 97 through 122 Copyright © 2017 Pearson Education, Inc.

Comparaison de données Comparaison de chaînes de caractères Les chaînes de caractères sont des objets String Les opérateurs == et != comparent les références fournies comme opérandes (non les objets référencés). Pour la comparaison des chaînes, la classe String dispose d'une méthode: equals. String ch1 = "Structures de "; String ch2 = "données"; ch1.equals (ch2); // faux   La méthode equalsIgnoreCase effectue la même chose sans distinguer les majuscules des minuscules. String ch1 = "bonjour "; String ch2 = "Bonjour"; ch1.equalsIgnoreCase (ch2); //vrai

Comparaison de données La méthode compareTo permet de comparer deux chaînes - Ch1.compareTo(ch2) Renvoie 0 si les deux chaînes sont égales, une valeur négative si ch1 est inférieure à ch2, une valeur positive dans le cas contraire La méthode charAt permet d'accéder à un caractère d'un rang donné String ch = "hello"; ch.charAt(0) correspond au caractère h

Comparaison de données Comparaison d’objets Les opérateurs == et != s'appliquent également aux objets, mais leur intérêt est très limité - porte uniquement sur les références Il faut définir dans ces cas des méthodes de comparaison propres à la classe - redéfinir la méthode equals

Les instructions de répétition: La boucle while Les instructions de répétition offrent la possibilité de répéter certaines instructions Instructions de répétition: l’instruction while, l’instruction do … while l’instruction for Syntaxe de l’instruction while: while (condition) // condition est une condition booléenne Instruction // est une instruction quelconque L’instruction while (condition) répète instruction tant que la condition est vraie La condition de poursuite est examinée avant chaque parcours (contrairement à la boucle do ... while qu’on verra plus tard)

Les instructions de répétition: La boucle while Exemple: La condition est évaluée au début, si celle-ci est fausse, la boucle ne sera jamais exécutée La variable compteur count est mise à jour au fur est à mesure – en cas de non mise à jour la boucle sera infinie (faire attention à cet aspect) La condition d’arrêt: Lorsque count est > 5 int count = 1; while (count <= 5) { System.out.println(count); count++; }

VOIR EX23 //******************************************************************** // Average.java Author: Lewis/Loftus // // Demonstrates the use of a while loop, a sentinel value, and a // running sum. import java.text.DecimalFormat; import java.util.Scanner; public class Average { //----------------------------------------------------------------- // Computes the average of a set of values entered by the user. // The running sum is printed as the numbers are entered. public static void main(String[] args) int sum = 0, value, count = 0; double average; Scanner scan = new Scanner(System.in); System.out.print("Enter an integer (0 to quit): "); value = scan.nextInt(); continue Copyright © 2017 Pearson Education, Inc.

while (value != 0) // sentinel value of 0 to terminate loop { count++; continue while (value != 0) // sentinel value of 0 to terminate loop { count++; sum += value; System.out.println("The sum so far is " + sum); System.out.print("Enter an integer (0 to quit): "); value = scan.nextInt(); } Copyright © 2017 Pearson Education, Inc.

Sample Run Enter an integer (0 to quit): 25 The sum so far is 25 The average is 39.333 continue System.out.println(); if (count == 0) System.out.println("No values were entered."); else { average = (double)sum / count; DecimalFormat fmt = new DecimalFormat ("0.###"); System.out.println("The average is " + fmt.format(average)); } Copyright © 2017 Pearson Education, Inc.

VOIR EX24 //******************************************************************** // WinPercentage.java Author: Lewis/Loftus // // Demonstrates the use of a while loop for input validation. import java.text.NumberFormat; import java.util.Scanner; public class WinPercentage { //----------------------------------------------------------------- // Computes the percentage of games won by a team. public static void main(String[] args) final int NUM_GAMES = 12; int won; double ratio; Scanner scan = new Scanner(System.in); System.out.print("Enter the number of games won (0 to " + NUM_GAMES + "): "); won = scan.nextInt(); continue Copyright © 2017 Pearson Education, Inc.

while (won < 0 || won > NUM_GAMES) { continue while (won < 0 || won > NUM_GAMES) { System.out.print("Invalid input. Please reenter: "); won = scan.nextInt(); } ratio = (double)won / NUM_GAMES; NumberFormat fmt = NumberFormat.getPercentInstance(); System.out.println(); System.out.println("Winning percentage: " + fmt.format(ratio)); Copyright © 2017 Pearson Education, Inc.

Sample Run Enter the number of games won (0 to 12): -5 Invalid input. Please reenter: 13 Invalid input. Please reenter: 7 Winning percentage: 58% continue while (won < 0 || won > NUM_GAMES) { System.out.print("Invalid input. Please reenter: "); won = scan.nextInt(); } ratio = (double)won / NUM_GAMES; NumberFormat fmt = NumberFormat.getPercentInstance(); System.out.println(); System.out.println("Winning percentage: " + fmt.format(ratio)); Copyright © 2017 Pearson Education, Inc.

Les instructions de répétition: do … while Syntaxe de l’instruction do … while: do suite d'instructions while (condition); //la condition est une expression booléenne quelconque La suite d’instructions est répétée tant et aussi longtemps que la condition est vraie Dans le cas du do, la suite d’instructions est exécutée au moins une fois contrairement à la boucle while  Faire attention à la mise à jour de la condition, sinon la boucle sera infinie

VOIR EX25 //******************************************************************** // ReverseNumber.java Author: Lewis/Loftus // // Demonstrates the use of a do loop. import java.util.Scanner; public class ReverseNumber { //----------------------------------------------------------------- // Reverses the digits of an integer mathematically. public static void main(String[] args) int number, lastDigit, reverse = 0; Scanner scan = new Scanner(System.in); continue Copyright © 2017 Pearson Education, Inc.

System.out.print("Enter a positive integer: "); continue System.out.print("Enter a positive integer: "); number = scan.nextInt(); do { lastDigit = number % 10; reverse = (reverse * 10) + lastDigit; number = number / 10; } while (number > 0); System.out.println("That number reversed is " + reverse); Copyright © 2017 Pearson Education, Inc.

Sample Run Enter a positive integer: 2896 That number reversed is 6982 continue System.out.print ("Enter a positive integer: "); number = scan.nextInt(); do { lastDigit = number % 10; reverse = (reverse * 10) + lastDigit; number = number / 10; } while (number > 0); System.out.println("That number reversed is " + reverse); Copyright © 2017 Pearson Education, Inc.

Comparing while and do The while Loop The do Loop statement condition true false condition evaluated The while Loop true condition evaluated statement false The do Loop Copyright © 2017 Pearson Education, Inc.

Les instructions de répétition: for Syntaxe de la boucle for: for (expression1; expression2; expression3) suite d'instructions Expression1: initialise la var compteur utilisée dans la boucle Expression2: définit la condition pour que la boucle se poursuive Expression3: indique comment faire varier la var compteur utilisée dans expression2

Logic of a for loop initialization condition evaluated false statement true increment Copyright © 2017 Pearson Education, Inc.

Les instructions de répétition: for Une boucle for est équivalente à la boucle while suivante: expression1 while ( expression2) { suite d'instructions; expression3; } La boucle for, en raison de l’emplacement de sa condition, est exécutée 0 ou plusieurs fois comme la boucle while.

VOIR EX26 //******************************************************************** // Multiples.java Author: Lewis/Loftus // // Demonstrates the use of a for loop. import java.util.Scanner; public class Multiples { //----------------------------------------------------------------- // Prints multiples of a user-specified number up to a user- // specified limit. public static void main(String[] args) final int PER_LINE = 5; int value, limit, mult, count = 0; Scanner scan = new Scanner(System.in); System.out.print("Enter a positive value: "); value = scan.nextInt(); continue Copyright © 2017 Pearson Education, Inc.

System.out.print("Enter an upper limit: "); limit = scan.nextInt(); continue System.out.print("Enter an upper limit: "); limit = scan.nextInt(); System.out.println(); System.out.println("The multiples of " + value + " between " + value + " and " + limit + " (inclusive) are:"); for (mult = value; mult <= limit; mult += value) { System.out.print(mult + "\t"); // Print a specific number of values per line of output count++; if (count % PER_LINE == 0) } Copyright © 2017 Pearson Education, Inc.

Sample Run Enter a positive value: 7 Enter an upper limit: 400 The multiples of 7 between 7 and 400 (inclusive) are: 7 14 21 28 35 42 49 56 63 70 77 84 91 98 105 112 119 126 133 140 147 154 161 168 175 182 189 196 203 210 217 224 231 238 245 252 259 266 273 280 287 294 301 308 315 322 329 336 343 350 357 364 371 378 385 392 399 continue System.out.print("Enter an upper limit: "); limit = scan.nextInt(); System.out.println(); System.out.println("The multiples of " + value + " between " + value + " and " + limit + " (inclusive) are:"); for (mult = value; mult <= limit; mult += value) { System.out.print(mult + "\t"); // Print a specific number of values per line of output count++; if (count % PER_LINE == 0) } Copyright © 2017 Pearson Education, Inc.

VOIR EX27 //******************************************************************** // Stars.java Author: Lewis/Loftus // // Demonstrates the use of nested for loops. public class Stars { //----------------------------------------------------------------- // Prints a triangle shape using asterisk (star) characters. public static void main(String[] args) final int MAX_ROWS = 10; for (int row = 1; row <= MAX_ROWS; row++) for (int star = 1; star <= row; star++) System.out.print("*"); System.out.println(); } Copyright © 2017 Pearson Education, Inc.

Output * ** *** **** ***** ****** ******* ******** ********* ********** //******************************************************************** // Stars.java Author: Lewis/Loftus // // Demonstrates the use of nested for loops. public class Stars { //----------------------------------------------------------------- // Prints a triangle shape using asterisk (star) characters. public static void main(String[] args) final int MAX_ROWS = 10; for (int row = 1; row <= MAX_ROWS; row++) for (int star = 1; star <= row; star++) System.out.print("*"); System.out.println(); } Copyright © 2017 Pearson Education, Inc.

Les instructions de répétition: boucles imbriquées Les boucles : while, do … while et for peuvent être également imbriquées – voir exemple suivant

//******************************************************************** // PalindromeTester.java Author: Lewis/Loftus // // Demonstrates the use of nested while loops. import java.util.Scanner; public class PalindromeTester { //----------------------------------------------------------------- // Tests strings to see if they are palindromes. public static void main(String[] args) String str, another = "y"; int left, right; Scanner scan = new Scanner(System.in); while (another.equalsIgnoreCase("y")) // allows y or Y System.out.println("Enter a potential palindrome:"); str = scan.nextLine(); left = 0; right = str.length() - 1; continue VOIR EX28 Copyright © 2017 Pearson Education, Inc.

while (str.charAt(left) == str.charAt(right) && left < right) { continue while (str.charAt(left) == str.charAt(right) && left < right) { left++; right--; } System.out.println(); if (left < right) System.out.println("That string is NOT a palindrome."); else System.out.println("That string IS a palindrome."); System.out.print("Test another palindrome (y/n)? "); another = scan.nextLine(); Copyright © 2017 Pearson Education, Inc.

Sample Run Enter a potential palindrome: radar That string IS a palindrome. Test another palindrome (y/n)? y able was I ere I saw elba abracadabra That string is NOT a palindrome. Test another palindrome (y/n)? n continue while (str.charAt(left) == str.charAt(right) && left < right) { left++; right--; } System.out.println(); if (left < right) System.out.println("That string is NOT a palindrome."); else System.out.println("That string IS a palindrome."); System.out.print("Test another palindrome (y/n)? "); another = scan.nextLine(); Copyright © 2017 Pearson Education, Inc.

Les instructions de branchement: break et continue Java dispose de deux instructions – instructions de branchement inconditionnel, qui affectent le déroulement de la boucle lorsque elles sont utilisées à l’intérieur de celle-ci Instruction break Lorsqu’elle est utilisée à l’intérieur d’une boucle, l’instruction break interrompe le déroulement de celle-ci en passant à l’instruction suivante L’instruction break n’a d’intérêt que si son exécution est liée à un choix (précédée par une condition, sinon elle serait exécutée à la première itération ce qui la rend inutile) Instruction continue Lorsqu’elle est utilisée à l’intérieur d’une boucle, l’instruction continue interrompe le déroulement de l’itération en cours et passe à l’itération suivante L’instruction continue n’a d’intérêt que si son exécution est liée à un choix (précédée par une condition)

La notion d’itérateurs - iterator Les itérateurs sont des objets permettant de parcourir un à un les différents éléments d’une collection donnée Un itérateur possède: La méthode iterator() qui, sur une collection donnée, fournit comme position le début de celle-ci La méthode next qui permet d’obtenir l’objet désigné par l’itérateur en le faisant avancer La méthode hasNext qui permet de savoir si l’itérateur est ou non en fin de collection (si la position suivante désigne ou non un élément)

La notion d’itérateurs - iterator Plusieurs classes parmi les classes standards de Java définissent des itérateurs La classe Scanner: La méthode hasNext de la classe Scanner retourne vrai s’il y’a un élément (ce n’est pas la fin) La méthode next retourne la prochaine chaine de caractères (entrée)

VOIR EX29 //******************************************************************** // URLDissector.java Author: Lewis/Loftus // // Demonstrates the use of Scanner to read file input and parse it // using alternative delimiters. import java.util.Scanner; import java.io.*; public class URLDissector { //----------------------------------------------------------------- // Reads urls from a file and prints their path components. public static void main(String[] args) throws IOException String url; Scanner fileScan, urlScan; fileScan = new Scanner(new File("urls.inp")); continue Copyright © 2017 Pearson Education, Inc.

// Read and process each line of the file while (fileScan.hasNext()) { continue // Read and process each line of the file while (fileScan.hasNext()) { url = fileScan.nextLine(); System.out.println("URL: " + url); urlScan = new Scanner(url); urlScan.useDelimiter("/"); // Print each part of the url while (urlScan.hasNext()) System.out.println(" " + urlScan.next()); System.out.println(); } Copyright © 2017 Pearson Education, Inc.

Sample Run URL: www.google.com www.google.com URL: www.linux.org/info/gnu.html www.linux.org info gnu.html URL: thelyric.com/calendar/ thelyric.com calendar URL: www.cs.vt.edu/undergraduate/about www.cs.vt.edu undergraduate about URL: youtube.com/watch?v=EHCRimwRGLs youtube.com watch?v=EHCRimwRGLs continue // Read and process each line of the file while (fileScan.hasNext()) { url = fileScan.nextLine(); System.out.println("URL: " + url); urlScan = new Scanner(url); urlScan.useDelimiter("/"); // Print each part of the url while (urlScan.hasNext()) System.out.println(" " + urlScan.next()); System.out.println(); } Copyright © 2017 Pearson Education, Inc.

La classe ArrayList La classe ArrayList est une classe appartenant au package java.util Un objet ArrayList est une collection permettant de stocker des objets Chaque objet de la collection est accessible par son index (valeur numérique) Le premier élément de la ArrayList se trouve à la position 0 La taille d’un objet ArrayList peut évoluer durant l’exécution du programme Plusieurs méthodes de la classe ArrayList Le type des éléments stockés dans la ArrayList est établit lors de la création de celle-ci ArrayList<String> noms= new ArrayList<String>; // collection d’objet de type String Une ArrayList ne peut stocker des types primitifs, d’où l’intérêt des classes enveloppes

//******************************************************************** // Beatles.java Author: Lewis/Loftus // // Demonstrates the use of a ArrayList object. import java.util.ArrayList; public class Beatles { //----------------------------------------------------------------- // Stores and modifies a list of band members. public static void main(String[] args) ArrayList<String> band = new ArrayList<String>(); band.add("Paul"); band.add("Pete"); band.add("John"); band.add("George"); continue VOIR EX30 Copyright © 2017 Pearson Education, Inc.

System.out.println(band); int location = band.indexOf("Pete"); continue System.out.println(band); int location = band.indexOf("Pete"); band.remove(location); System.out.println("At index 1: " + band.get(1)); band.add(2, "Ringo"); System.out.println("Size of the band: " + band.size()); int index = 0; while (index < band.size()) { System.out.println(band.get(index)); index++; } Copyright © 2017 Pearson Education, Inc.

Output [Paul, Pete, John, George] [Paul, John, George] At index 1: John Size of the band: 4 Paul John Ringo George continue System.out.println(band); int location = band.indexOf("Pete"); band.remove(location); System.out.println("At index 1: " + band.get(1)); band.add(2, "Ringo"); System.out.println("Size of the band: " + band.size()); int index = 0; while (index < band.size()) { System.out.println(band.get(index)); index++; } Copyright © 2017 Pearson Education, Inc.

La boucle For-each Il s’agit d’une variante de la boucle for utilisée dans le cas des itérateurs Exemple: Soit library une liste d’objets de type book – Arraylist<Book> for( Book myBook: library) System.out.println(myBook) Équivalent à: Book myBook; While(bookList.hasnext()) // bookList itérateur { myBook=bookList.next(); }