Structure générale d’un programme avec un Scanner

Les Scanner sont utilisés pour lire du texte à partir de différentes sources. Pour commencer, on utilisera un Scanner qui surveille System.in pour complémenter le PrintStream (System.out) qu’on utilise déjà pour afficher des messsages texte à la console. Bref, les Scanner vont nous permettre de lire des réponses de l’utilisateur à la console et d’avoir des programmes interactifs.

Si vous ne l’aviez pas deviné, System.in et System.out sont les entrées et sorties standard de votre système d’exploitation, notamment la console.

La structure globale d’un programme qui utilise un Scanner est la suivante :

1
2
3
4
5
6
7
import java.util.*; // importer la définition de Scanner de java.util

void main() {
    Scanner console = new Scanner(System.in); // déclarer un Scanner pour la console

    // ... le reste du programme
}

Déclarer un Scanner

Le format de la déclaration d’un Scanner est le suivant :

1
Scanner nom = new Scanner(source);

où nom est le nom de la variable qui contiendra l’objet Scanner et source est la source de texte que le Scanner lira. Le nom est généralement un reflèt précis de la source.

Pour lire de la console

On utilise System.in, l’entrée standard, comme source.

1
Scanner console = new Scanner(System.in);

Pour lire un String

On utilise un String comme source.

1
2
String text = "Bonjour, le monde!";
Scanner textReader = new Scanner(text);

Fermer un Scanner

On ne ferme jamais le Scanner pour la console parce qu’on s’en sert généralement jusqu’à la fin du programme interactif. Ce Scanner sera fermé automatiquement en arrivant à la fin de la méthode main.

Par contre, c’est important de fermer les Scanner pour toutes les autres sources de texte, comme un fichier ou un String. On ferme un Scanner avec la méthode close() une fois qu’on a finit de le lire. Par exemple :

1
textReader.close();

Introduction aux méthodes de Scanner - extraire les données d’un String

Pour comprendre comment les méthodes de Scanner fonctionnent, on va les tester sur différents String. Les sections plus bas montrent le Scanner dans le contexte d’un programme interactif.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
String words = "\n   \tBonjour le monde!";
Scanner wordsReader = new Scanner(words); // Scanner qui utilise le texte 'words' comme source

String word; // variable pour stocker le mot lu

word = wordsReader.next(); // ignore les espaces initiaux puis saisit tout jusqu'au prochain espace, soit "Bonjour"
System.out.println(word);

word = wordsReader.next(); // saisit "le"
System.out.println(word); 

word = wordsReader.next(); // saisit "monde!"
System.out.println(word); 
wordsReader.close();

1
2
3
4
5
6
7
String info = "Marie 15 85.5";
Scanner infoReader = new Scanner(info);
String nom = infoReader.next(); // saisir le nom
int age = infoReader.nextInt(); // saisir le texte pour le nombre entier
double moyenne = infoReader.nextDouble(); // saisir le nombre décimal
infoReader.close();
System.out.printf("%s a %d ans et sa moyenne est %.1f\n", nom, age, moyenne);

1
Marie a 15 ans et sa moyenne est 85.5

1
2
3
4
5
6
7
8
9
10
String info = "Marie 15 85.5";
Scanner infoReader = new Scanner(info);

infoReader.useLocale(Locale.CANADA); // spécifie le format "."

String nom = infoReader.next(); 
int age = infoReader.nextInt(); 
double moyenne = infoReader.nextDouble(); 
infoReader.close();
System.out.printf("%s a %d ans et sa moyenne est %.1f\n", nom, age, moyenne);

Version interactive : lire la console

En interagissant à la console, c’est important de donner des invites de réponse claires et spécifiques à l’utilisateur afin qu’elle sache quoi taper et avec quel format, si nécessaire.

Voici un exemple en transformant le programme précédent en un programme interactif :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Scanner console = new Scanner(System.in); // source = entrée standard
console.useLocale(Locale.CANADA_FRENCH); // spécifie le format ","

System.out.print("Quel est votre prénom? "); // invite de réponse
String nom = console.next(); 

System.out.print("Quel est votre âge? "); // invite de réponse
int age = console.nextInt(); 

// invite de réponse qui reflète la déclaration du Locale plus haut dans le code
System.out.print("Quelle est votre moyenne? (utilisez le ',' comme décimal) "); 
double moyenne = console.nextDouble(); 

System.out.printf("%s a %d ans et sa moyenne est %.1f\n", nom, age, moyenne);

// notez qu'on n'a pas fermé le Scanner pour la console

Enrichissement : valider la réponse avant de la saisir

Cette section est annotée comme “avancée” parce qu’elle incorpore des éléments de programmation que nous n’avons pas encore vus avec Java, notamment les opérations logiques et les boucles. Si vous ne comprenez pas tout de suite, ne vous inquiétez pas. Vous aurez l’occasion de revoir ces concepts plus tard dans le cours.

Si vous comprenez bien comment formuler une invite de réponse précise et comment assurer la cohérence entre votre invite et ce que vous avez écrit dans votre code, peut-être que vous ne serez pas satisfait de laisser une erreur de frappe par l’utilisateur faire planter votre programme. C’est là qu’on peut commencer à rendre le code plus tolérante aux erreurs en les gérant avant qu’elles ne causent des problèmes.

Pour valider une réponse avant de la saisir, on utilise les méthodes hasNextInt() et hasNextDouble() pour vérifier si le prochain mot est convertible en int ou double respectivement. Si la réponse est valide, on la saisit, la convertit et la conserve. Sinon, on doit vider le Scanner pour préparer la saisie suivante, alors on saisit la réponse comme texte sans la conserver. On peut également afficher un message d’erreur et inviter l’utilisateur à réessayer.

1
2
3
4
5
6
7
8
9
10
11
Scanner console = new Scanner(System.in);

System.out.print("Saisissez un nombre entier : ");
while (!console.hasNextInt()) {
    console.next(); // vider le Scanner du jeton incorrect
    System.out.println("Ce n'est pas un nombre entier valide.");
    System.out.print("Saisissez un nombre entier : ");
}

int number = console.nextInt();
System.out.println("Vous avez saisi " + number);

L’opérateur ! est l’inverse logique (“not”). Il transforme true en false et false en true. Dans ce contexte, !console.hasNextInt() signifie “tant que le Scanner n’a pas un nombre entier valide comme prochain jeton”.