Écrire un programme intitulé WordSearch qui permet à l'utilisateur de saisir
un texte et un mot à chercher à l'intérieur de ce texte. L'utilisateur
commence par saisir le texte à inspecter en premier (on supposera que celui-ci
ne contient que des mots séparés par des espaces et ne contient pas de signes
de ponctuation). Ensuite, il saisit le mot recherché. Le programme doit
signaler à l'utilisateur la position de chaque occurrence du mot dans le texte
s'il arrive à le trouver et indiquer, au cas contraire, que le mot est
introuvable.
L'exemple suivant montre le déroulement attendu du programme. Ce dernier sollicite l'utilisateur pour donner le texte à fouiller puis demande le mot à chercher. Il affiche pour chaque occurrence la position du mot dans le texte (ici une seule occurrence à la 8e position).
Texte à fouiller: Lorem ipsum dolor sit amet consectetur adipiscing elit Sed non risus Suspendisse lectus tortor dignissim sit amet adipiscing nec ultricies sed dolor Mot à trouver: elit Le mot elit apparait à la place no.8.
Une solution possible basée sur la méthode split des String est donnée
dans le programme suivant :
package org.apiacoa.teaching.oop;
import java.util.Scanner;
public class WordSearch {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("Texte à fouiller :");
String texte = scan.nextLine();
System.out.println("Mot à chercher :");
String mot = scan.nextLine();
String[] lesMots = texte.split("\\p{javaWhitespace}+");
boolean found = false;
for (int i = 0; i < lesMots.length; i++) {
if (lesMots[i].equals(mot)) {
found = true;
System.out.printf("Le mot %s apparaît à la position %d.%n", mot, i + 1);
}
}
if (!found) {
System.out.printf("Le mot %s n'apparaît pas dans le texte.%n", mot);
}
scan.close();
}
}
Le cœur de la solution est l'appel
texte.split("\\p{javaWhitespace}+"). Comme tout appel à split, celui-ci
produit un tableau de chaînes de caractères correspondant au découpage de la
chaîne d'origine (ici texte) en morceaux délimités par le paramètre de
l'appel. On utilise ici un paramètre un peu particulier, décrit par le texte
"\\p{javaWhitespace}+". La première partie du texte \\p{javaWhitespace]
est une sorte de joker qui indique qu'on utilise comme délimiteur n'importe
quel caractère considéré comme un espace en Java (par exemple une
tabulation). La seconde partie + indique que le délimiteur peut en fait être
constitué d'autant de caractères « espace » qu'on le souhaite (avec au moins
un caractère).
On peut se passer de split, mais le programme devient alors beaucoup plus
complexe puisqu'on doit en gros programmer un équivalent (en plus simple) de
cette méthode. On obtient par exemple le programme suivant :
package org.apiacoa.teaching.oop;
import java.util.Scanner;
public class WordSearchNoSplit {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("Texte à fouiller :");
String texte = scan.nextLine();
System.out.println("Mot à chercher :");
String mot = scan.nextLine();
boolean found = false;
boolean dansMot = true;
int numMot = 0;
int debutMot = 0;
int finMot = 0;
for (int i = 0; i < texte.length(); i++) {
// on regarde si on entre ou on sort d'un mot
boolean compare = false;
if (Character.isWhitespace(texte.charAt(i)) || i == texte.length() - 1) {
if (dansMot) {
// on quitte le mot du texte
numMot++;
dansMot = false;
compare = true;
if (Character.isWhitespace(texte.charAt(i))) {
finMot = i - 1;
} else {
finMot = i;
}
}
} else {
if (!dansMot) {
// on découvre un nouveau mot
debutMot = i;
dansMot = true;
}
}
if (compare) {
// on compare le mot trouvé avec le mot cherché
// d'abord la longueur
if (finMot - debutMot + 1 == mot.length()) {
int j = 0;
while (j < mot.length() && texte.charAt(debutMot + j) == mot.charAt(j)) {
j++;
}
if (j == mot.length()) {
// on a trouvé le mot
found = true;
System.out.printf("Le mot %s apparaît à la position %d.%n", mot, numMot);
}
}
compare = false;
}
}
if (!found) {
System.out.printf("Le mot %s n'apparaît pas dans le texte.%n", mot);
}
scan.close();
}
}