Discussion :

[messi1987]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[joel.drigo]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[hugoclo]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[joel.drigo]

Salut Hugoclo,

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

1. Pourquoi utiliser un StringTokenizer alors qu'un simple split() est suffisant et beaucoup plus simple ?
2. Pourquoi autant de séparateurs alors qu'on sait que l'espace est le seul séparateur ?
3. Autant créer une map paramétrée (Map<String, Integer>) pour éviter d'avoir à caster.
4. 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().
5. Quand tu déclares des variables, fait en sorte que leur portée soit minimum (déclare-les là où tu en a besoin).
6. 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 :

   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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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");
		}
 
	}
 
}

[messi1987]

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