Compter le nombre des mots

Version imprimable

Bonjour,
svp j'ai un fichier text son contenu est

Code:

1
2
3
 
hot high FALSE no sunny
hot high true yes sunny

Mon code suivant compte le nombre total de mots dans mon fichier

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package countwords;
import java.io.BufferedReader;
import java.io.FileReader;
 
 
/**
 *
 * @author user
 */
public class CountWords {
 
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws Exception{
 
        System.out.println ("Counting Words");       
       FileReader fr = new FileReader ("C:\\Users\\user\\Desktop\\weather.nominal.txt");        
       BufferedReader br = new BufferedReader (fr);     
       String line = br.readLine();
       int count = 0;
       while (line != null) {
          String [] parts = line.split(" ");
          for( String w : parts)
          {
            count++;        
          }
          line = br.readLine();
       }         
       System.out.println(count);
    }
        // TODO code application logic here
    }

maitenant je veux compter l’occurrence de chaque mot cad
hot=2
high=2
sunny=2
false=1
true=1
no=1
yes=1
comment faire pour faire cela merci d'avance

Salut,

Tu peux utiliser une map, qui permet d'associer des clefs (key) et des valeurs (value). Par exemple, une HashMap<String, Integer>, te permettra d'associer à chaque mot (String), un compteur (Integer), sur le principe suivant :
Code:

1 2 3 4 5 6 7 if ( map.containsKey(mot) ) { // si map contient mot map.put( mot, map.get( mot ) + 1 ); // ajouter 1 à la valeur qui été associée à mot et réassocier le résultat avec mot } else { map.put( mot, 1 ); // associer 1 à mot }
Ensuite, pour afficher le résultat, tu pourras faire :
Code:

1 2 3 for(Map.Entry<String, Integer> entry : map.entrySet() ) { System.out.println( entry.getKey() + "=" + entry.getValue() ); }

Salut,
Ici tu trouveras un début de réponse.
ou directement

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
import java.io.*;
import java.util.*;
 
class CompterMots
{
  public static void main (String[] argv) throws IOException
    {
      Hashtable table = new Hashtable();
      BufferedReader entree = new BufferedReader(new FileReader(argv[0]));
      String ligne;
      StringTokenizer st;
      String mot;
      int nbOcc;
 
      while ((ligne = entree.readLine()) != null)
	{
	  st = new StringTokenizer(ligne, " ,.;:_-+*/\\.;\n\"'{}()=><\t!?");
	  while(st.hasMoreTokens())
	    {
	      mot = st.nextToken();
	      if (table.containsKey(mot))
		{
		  nbOcc = ((Integer)table.get(mot)).intValue();
		  nbOcc++;
		}
	      else nbOcc = 1;
	      table.put(mot, new Integer(nbOcc));
	    }
	}
 
      Enumeration lesMots = table.keys();
      while (lesMots.hasMoreElements())
	{
	  mot = (String)lesMots.nextElement();
	  nbOcc = ((Integer)table.get(mot)).intValue();
	  System.out.println("Le mot " + mot + " figure " +
			     nbOcc + " fois");
	}
    }
}

trouvez ici

Salut Hugoclo,

Ta solution est super compliquée alors qu'elle pourrait être beaucoup plus simple :

Pourquoi utiliser un StringTokenizer alors qu'un simple split() est suffisant et beaucoup plus simple ?
Pourquoi autant de séparateurs alors qu'on sait que l'espace est le seul séparateur ?
Autant créer une map paramétrée (Map<String, Integer>) pour éviter d'avoir à caster.
Lorsqu'on veut parcourir les couples clef/valeur, autant utiliser entrySet(), plutôt que keySet() (ou keys() de HashTable, qui t'oblige en plus à parcour une Enumeration, qui ne simplifie pas le parcourt)), et de faire des get().
Quand tu déclares des variables, fait en sorte que leur portée soit minimum (déclare-les là où tu en a besoin).
HashTable est une implémentation de map qui est synchronizée : ça ne sert à rien dans ce contexte. De manière générale, ne jamais utiliser cette classe (ce qui est d'ailleurs conseillé par la doc :

Citation:

If a thread-safe implementation is not needed, it is recommended to use HashMap in place of Hashtable. If a thread-safe highly-concurrent implementation is desired, then it is recommended to use ConcurrentHashMap in place of Hashtable.

.

En plus, tu ne fermes pas le reader, ce qu'il est indispensable de faire (D'ailleurs, je viens de remarquer que ce n'était pas fait dans le programme de @messi1987)

Ton programme modifié :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 public class CompterMots { public static void main(String[] argv) throws IOException { Map<String, Integer> table = new HashMap<>(); try (BufferedReader entree = new BufferedReader(new FileReader(argv[0]))) { for (String ligne = entree.readLine(); ligne != null; ligne = entree .readLine()) { for (String mot : ligne.split(" ")) { if ( table.containsKey( mot ) ) { table.put( mot , table.get(mot) + 1 ); } else { table.put( mot , 1 ); } } } } // le reader est fermé ici for (Map.Entry<String, Integer> entry : table.entrySet()) { String mot = entry.getKey(); int nbOcc = entry.getValue(); System.out.println("Le mot " + mot + " figure " + nbOcc + " fois"); } } }

29/11/2014, 15h11
messi1987

Merci joel.drigo votre solution fonctionne très bien.