Pour faire cette partie, il est nécessaire d'avoir terminé la partie 1
Java permet très facilement de récupérer des documents accessibles par
le réseau, en particulier à travers le protocole http
. L'objectif de
cette amélioration est d'ajouter à l'analyseur la possibilité de lire
de tels documents.
L'objectif ici est de coder une nouvelle implémentation de l'interface
Lecteur
qui, au lieu de lire les caractères dans un fichier
sur la machine ou au clavier, va lire les caractères dans un fichier
sur le réseau. Pour cela nous allons utiliser la classe java.net.URL
.
La première étape consiste à lire la documentation de la classe java.net.URL
. En
particulier, on s'attachera à lire la documentation du constructeur
qui prend une String
en argument, ainsi que la documentation
de la méthode openStream()
.
La classe java.net.URL
nous permet ainsi de récupérer un InputStream
pour lire dans le fichier désigné par cette URL. Créer une classe
LecteurReseau
qui implémente l'interface Lecteur
.
On pourra prendre comme modèle les classes LecteurDeFichier
et LecteurClavier
de la première partie. Le constructeur de la classe
prendra en argument une String
correspondant à l'URL du
fichier à lire.
Nous avons à présent le choix entre trois lecteurs possibles:
LecteurClavier
: s'il n'y a pas de fichier spécifiéLecteurDeFichier
: si un fichier est spécifié en plus du mot à reconnaîtreLecteurReseau
: si une URL est spécifiée en plus du mot à reconnaître
Pour faire la différence entre une URL et un nom de fichier, on
supposera qu'une URL contient toujours la chaîne de caractères
"://"
contrairement à un nom de fichier.
Modifier la méthode main
de la classe Analyseur
de
façon à utiliser un LecteurReseau
lorsqu'une URL est donnée
comme nom de fichier.
Le but ici est de permettre de pouvoir utiliser des expressions
régulière (comme le programme Unix grep
) et pas seulement des
mots.
Pour cela créer un champ “pattern
” de la classe java.util.regex.Pattern
.
Pour initialiser ce champ, on utilisera la méthode statique Pattern.compile(String regex)
.
Modifier ensuite la classe Analyseur
de façon à reconnaître une expression régulière et pas un mot.
Pour tester une ligne, on pourra utiliser pattern.matcher(laLigneATester).find()
.
Créer une classe Ligne
qui contient deux champs:
un champ numero
qui est un int
et un champ
texte
qui est un String
.
Modifier ou créer un constructeur pour qu'il prenne des arguments permettant
d'initialiser ces deux champs.
Ajouter les deux méthodes suivantes:
public int getNumero() { ... } public int getTexte() { ... }
permettant de récupérer les valeurs de ces champs.
On veut modifier la méthode analyse afin qu'elle renvoie une collection de
lignes (type Collection<Ligne>
). Cela nous permettra d'afficher
des informations supplémentaires sur le résultat comme par exemple le
nombre de lignes trouvées.
Commencer par changer la signature de la méthode.
L'interface Collection
se trouve dans le package java.util
.
Déclarer une variable de type Collection<Ligne>
.
Comme Collection
est une interface, il faut une classe qui
l'implémente. On trouvera un ensemble de telles classes dans la
documentation de l'interface Collection
.
Choisir une implémentation et l'utiliser pour initialiser la variable
au début de la méthode analyse()
.
Changer les instructions qui faisaient l'affichage pour, à la place, créer une nouvelle ligne et l'ajouter à la collection.
Enfin, renvoyer la collection.
Dans la méthode main
, créer une variable de type
Collection
qui est initialisée par l'appel à la méthode
analyse()
.
Créer ensuite une variable de type Iterator<Ligne>
que l'on
initialisera grâce à la méthode iterator()
de l'interface
Collection
.
Utiliser les méthodes next()
et hasNext()
de
l' Iterator
pour parcourir la collection et afficher chaque
ligne précédée de son numéro.
Si le résultat de l'analyse est vide, on affichera un message, sinon
on affichera le nombre de lignes trouvées (chercher les bonnes
méthodes dans l'interface Collection
).