Interaction Utilisateur avec Scanner

Les bases de Java vues précédemment ne permettaient pas d'interagir avec l'utilisateur. Java fournit la classe java.util.Scanner (introduite en Java 5) pour capturer les entrées de l'utilisateur. Les méthodes courantes pour lire des chaînes sont next() et nextLine(), souvent précédées par hasNext() ou hasNextLine() pour vérifier la disponibilité de données.

Méthode next()

La méthode next() lit un mot jusqu'au prochain espace blanc. Les espaces blancs avant le premier caractère valide sont ignorés.

import java.util.Scanner;

public class ScannerExample {
   public static void main(String[] args) {
       Scanner inputReader = new Scanner(System.in); // Crée un objet Scanner pour lire depuis la console

       System.out.println("Utilisation de next() :");
       if (inputReader.hasNext()) { // Vérifie s'il y a une prochaine chaîne
           String word = inputReader.next();
           System.out.println("Entrée reçue : " + word);
           // Exemple d'entrée : bonjour le monde
           // Sortie : Entrée reçue : bonjour
       }
       inputReader.close(); // Ferme le scanner pour libérer les ressources
   }
}

Méthode nextLine()

La méthode nextLine() lit toute la ligne jusqu'à ce que l'utilisateur appuie sur Entrée. Elle capture également les espaces.

import java.util.Scanner;

public class ScannerExample {
   public static void main(String[] args) {
       Scanner inputReader = new Scanner(System.in);

       System.out.println("Veuillez entrer des données :");
       String fullLine = inputReader.nextLine(); // Lit toute la ligne, y compris les espaces
       System.out.println("Ligne entrée : " + fullLine);

       inputReader.close();
   }
}

Lecture de Types Numériques

On peut utiliser des méthodes comme hasNextInt(), nextInt(), hasNextDouble(), etc., pour lire des types numériques spécifiques.

import java.util.Scanner;

public class ScannerNumeric {
   public static void main(String[] args) {
       Scanner inputReader = new Scanner(System.in);

       System.out.println("Veuillez entrer un entier :");
       if (inputReader.hasNextInt()) { // Vérifie si l'entrée est un entier
           int number = inputReader.nextInt();
           System.out.println("Entier entré : " + number);
       } else {
           System.out.println("Ce n'est pas un entier valide.");
       }

       inputReader.close();
   }
}

Différence entre next() et nextLine()

• next() : Lit jusqu'au prochain délimiteur (espace, tabulation, nouvelle ligne). Il ignore les délimiteurs précédents et ne lit pas les espaces dans la chaîne.
• nextLine() : Lit jusqu'au prochain caractère de nouvelle ligne (Entrée). Il inclut les espaces dans la chaîne retournée.

Structures de Contrôle

Structure Séquentielle

Les instructions sont exécutées dans l'ordre où elles apparaissent. C'est la structure de base de tout algorithme.

Structures de Sélection

• if : Exécute un bloc de code si une condition est vraie.
• if-else : Exécute un bloc de code si la condition est vraie, et un autre bloc si elle est fausse.
• if-else if-else : Permet de tester plusieurs conditions séquentiellement.
• if imbriqué : Un statement if à l'intérieur d'un autre.

public class SelectionControl {
       public static void main(String[] args) {
           int score = 85;

           if (score > 60) {
               System.out.println("Admis");
               if (score > 80) {
                   System.out.println("Mention Excellent");
               }
           } else if (score > 0) {
               System.out.println("Non admis");
           } else {
               System.out.println("Absence");
           }
       }
   }
   

Structure switch

Permet de choisir un bloc de code à exécuter parmi plusierus options basées sur la valeur d'une expression (type char, byte, short, int, String, ou énumérations).

public class SwitchControl {
       public static void main(String[] args) {
           char grade = 'B'; // Peut aussi être une chaîne depuis Java 7

           switch (grade) {
               case 'A':
                   System.out.println("Très bien");
                   break; // Sort de la structure switch
               case 'B':
                   System.out.println("Bien");
                   break;
               case 'C':
                   System.out.println("Passable");
                   break;
               default: // Cas par défaut si aucune correspondance
                   System.out.println("Insuffisant");
                   break;
           }
       }
   }
   

Structures de Boucle

Boucle while

Répète un bloc de code tant qu'une condition booléenne est vraie.

public class WhileLoop {
       public static void main(String[] args) {
           // Calcul de la somme des nombres de 1 à 100
           int counter = 0;
           int sum = 0;
           while (counter < 100) {
               counter++;
               sum += counter;
           }
           System.out.println("Somme (while) : " + sum); // Affiche 5050
       }
   }
   

Boucle do-while

Similaire à while, mais le bloc de code est exécuté au moins une fois avant que la condision ne soit vérifiée.

public class DoWhileLoop {
       public static void main(String[] args) {
           int counter = 0;
           int sum = 0;
           do {
               counter++;
               sum += counter;
           } while (counter < 100);
           System.out.println("Somme (do-while) : " + sum); // Affiche 5050
       }
   }
   

Boucle for

Idéale lorsque le nombre d'itérations est connu à l'avance. Structure : for(initialisation; condition; iteration).

public class ForLoop {
       public static void main(String[] args) {
           int sum = 0;
           // Boucle infinie exemple : for (;;) { ... }

           // Exercice : Afficher les nombres de 1 à 1000 divisibles par 5, 3 par ligne
           for (int i = 1; i <= 1000; i++) {
               if (i % 5 == 0) {
                   System.out.print(i + "\t"); // \t pour tabulation
                   if (i % (3 * 5) == 0) { // Condition pour nouvelle ligne tous les 3 nombres
                       System.out.println();
                   }
               }
           }
           System.out.println(); // Nouvelle ligne après la liste

           // Exercice 2 : Table de multiplication (9x9)
           for (int i = 1; i <= 9; i++) {
               for (int j = 1; j <= i; j++) {
                   System.out.print(j + "*" + i + "=" + (i * j) + "\t");
               }
               System.out.println(); // Nouvelle ligne après chaque ligne de la table
           }
       }
   }
   

Boucle for-each (foreach)

Permet de parcourir facilement les éléments d'un tableau ou d'une collection.

public class EnhancedForLoop {
       public static void main(String[] args) {
           int[] numbers = {10, 20, 30, 40, 50}; // Déclaration et initialisation d'un tableau

           // Parcours avec for-each
           for (int num : numbers) {
               System.out.println(num); // Affiche chaque élément : 10, 20, 30, 40, 50
           }

           // Équivalent avec une boucle for classique
           // for (int i = 0; i < numbers.length; i++) {
           //     System.out.println(numbers[i]);
           // }
       }
   }
   

break et continue

• break : Permet de sortir immédiatement d'une boucle (while, do-while, for, for-each) ou d'une structure switch.
• continue : Permet de passer à l'itération suivante de la boucle, en sautant le reste du code dans le bloc pour l'itération courante.
• Étiquettes (Labels) : Possibilité d'utiliser une étiquette (ex: label:) avant une boucle pour spécifier quelle boucle break ou continue doit affecter.

public class BreakContinue {
       public static void main(String[] args) {
           // Afficher les nombres premiers entre 101 et 150
           // Utilisation de 'continue outer' pour sauter au prochain 'i'
           outerLoop: for (int i = 101; i <= 150; i++) {
               // On teste la divisibilité par des nombres jusqu'à la racine carrée de i,
               // mais pour simplifier ici, on va jusqu'à i/2.
               for (int j = 2; j < i / 2; j++) {
                   if (i % j == 0) {
                       continue outerLoop; // Si divisible, ce n'est pas premier, passer au prochain i
                   }
               }
               System.out.print(i + " "); // Si aucune division n'a eu lieu, c'est un nombre premier
           }
           System.out.println();
       }
   }