Compter les nombres d'occurrences des mots d'un texte

Version Client/Serveur

Objectifs : Mise en œuvre des sockets en mode connecté. Utilisation des classes Socket et ServerSocket du paquetage java.net. 

Révision : Gestion des exceptions - Manipulation des flux d’entrée-sortie.

Note : On pourra utiliser les supports de cours sur les sockets clients et les socket serveurs.

Dans cet exercice nous écrivons un serveur qui va lister les différents mots d'un fichier texte en comptant pour chaque mot son nombre d'occurrences.
On écrira aussi un client qui doit se connecter, lire le fichier en l'envoyant au serveur et attendre la réponse (la liste des mots et leurs occurrences).

1. Modifier la classe CompterMots (donnée). 
   
   • Créer un constructeur prenant en paramètre deux flux qui permettront de lire le texte et d’envoyer la liste finale. 
     On pourra utiliser comme flux d'entrée un objet de type BufferedReader et comme flux de sortie un objet de type PrintStream.
     
   • Ecrire une méthode qui permet de compter les mots d’un texte lu sur le flux en entrée.
     Le texte lu sera terminé par une ligne comportant uniquement le mot FIN.
     Note : pour comparer deux chaînes de caractères on utilise la méthode equals() ou la méthode equalsIgnoreCase() de la classe String. Ces deux méthodes acceptent un objet de type String en paramètre et le compare à l'objet sur lequel on appelle la méthode.
     
   • Écrivez une méthode main() qui lit du texte sur l'entrée standard et affiche le résultat sur la sortie standard..
     Consulter la classe System du package java.lang pour voir le type des objets représentant les flux d'entrée/sortie standards (in et out).
     
2. Coder une classe avec main() correspondant au serveur. Cette classe utilisera la classe CompterMots. Vous pouvez vous baser sur l'exemple du cours.
   
3. Coder une classe correspondant au client. Vous pouvez vous baser sur l'exemple du cours.
   
   • Créer un premier client qui lit les différentes lignes sur l'entrée standard, les envoie au serveur et affiche ce qui est renvoyé par le serveur.
     
   • Modifier le client pour lire le texte depuis un fichier et écrire le résultat dans un autre fichier.
     Les noms des fichiers sont donnés en paramètre du programme.
     
4. Modifier le serveur de façon à lancer un thread pour chaque requête.
   A vous de choisir si vous voulez que la classe correspondant au serveur dérive de la classe Thread ou implémente l'interface Runnable ou si vous voulez que ce soit la classe CompterMots qui gère le thread.

La classe CompterMots

import java.io.*;
import java.util.*;

class CompterMots {

     public static void main (String[] argv) {

     // les parametres sont-ils précisés
     if (argv.length < 2) {
	System.err.println
		("usage : java CompterMots fichier_texte fichier_resultat");
     }

     try {
      	Hashtable table = new Hashtable();
      	BufferedReader entree = new BufferedReader(new FileReader(argv[0]));
      	String ligne;
      	StringTokenizer st;

      	// lecture du fichier ligne à ligne
      	while ((ligne = entree.readLine()) != null) {
            // creation du découpeur de ligne
            st = new StringTokenizer(ligne, " ,.;:_-+*/\\.;\n\"'{}()=><\t!?");

             // tant qu'il y a des mots
             while (st.hasMoreTokens()) {
                // on recupere le mot
                String mot = st.nextToken();

                // on le cherche dans la table
                Object obj = table.get(mot);
                // s'il n'y est pas
                if
                  (obj == null)
		  // on l'ajoute
                  table.put(mot, new Integer(1));
                else {
                  // sinon on incrémente
                  Integer prec = (Integer) obj;
                  table.put(mot, new Integer(prec.intValue()+1));
                }
             }
       	}

       	// ne pas oublier de fermer le fichier
       	entree.close();

	Enumeration lesMots = table.keys();

        // Creation du fichier resultat
	PrintWriter fluxSortie = new PrintWriter(new FileWriter(argv[1]));

        // parcours de toutes les entrées de la table de hashing

        while (lesMots.hasMoreElements()) {
		// on recupere le mot suivant
                String mot = (String)lesMots.nextElement();
                // on cherche l'Integer correspondant dans la table
                Object obj = table.get(mot);
                if
                  (obj == null)
                  System.err.println("erreur");
                else {
                  // on affiche sur l'écran et dans le fichier resultat
                  Integer nb = (Integer) obj;
                  System.out.println("Le mot "+mot+" est présent "+nb+" fois");
		  fluxSortie.println("Le mot "+mot+" est présent "+nb+" fois");
                }
        }

	// ne pas oublier de fermer le fichier
        fluxSortie.close();

    } catch(FileNotFoundException e1) {
      System.out.println("Le fichier "+argv[0]+" n'existe pas");
    } catch(IOException e2) {
      System.out.println("Erreur pendant la lecture du fichier");
    }
  }
}

Extrait de la classe java.lang.System

java.lang
Class System

java.lang.Object
  |
  +--java.lang.System

public final class System

extends Object

The System class contains several useful class fields and methods. It cannot be instantiated.

Among the facilities provided by the System class are standard input, standard output, and error output streams; access to externally defined "properties"; a means of loading files and libraries; and a utility method for quickly copying a portion of an array.

Since:

JDK1.0

Field Summary
static PrintStream	err           The "standard" error output stream.
static InputStream	in           The "standard" input stream.
static PrintStream	out           The "standard" output stream.

  ...