Discussion :

[mimihh]

Bonjour tout le monde,

j'ai un ensemble de fichiers contenant chacun un mot par ligne je voulais comparer ces fichiers afin de voir le mots qui existe dans la majorité des fichiers
quelqu'un pourrais me proposer une méthode ou un algorithme??
Merci d'avance.

[thelvin]

A priori, lire tous les fichiers l'un après l'autre, de sorte de construire une HashMap indexée par les mots, qui indique dans combien de fichiers apparaît ce mot.

Et à la fin tu regardes lequel apparaît dans le plus grand nombre.

[mimihh]

j'ai effectué la lecture de mes fichiers mais j'ai pas une idée sur la Hash map pourriez vous me dire de quoi s'agit il et comment puisse je l'appliquer pour indexer mes fichiers

[joel.drigo]

Salut,

une Map (et dont HashMap est une implémentation particulière) est une classe qui permet d'associer des clefs avec des valeurs indéxées sur ces clefs.

Ce que dit @thelvin c'est d'utiliser en clef les mots et de leur associer un compteur de fichier, ce qui te permettra ensuite de connaitre le nombre de fichiers qui stockent chaque mot, et donc de connaitre ceux qui sont stockés dans le plus grand nombre de fichier (ou toutes autres conditions que tu entends par "majorité de fichier").

Tu vas donc utiliser une map dont les clefs sont des mots (donc des String) et les valeurs de compteurs, donc des Integer (qui devrait être suffisant pour stocker un nombre de fichiers conséquents)

Pour créer ta map :

Code :

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

Map<String, Integer> map = new HashMap<String, Integer>();

Ensuite, en gros tu vas avoir :

Chaque fois que tu lis un mot dans un fichier, tu fais quelque chose comme ça (en supposant qu'un mot se trouve qu'une seule fois dans chaque fichier) :

Code :

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

1
2
3
4
5
if ( map.contains(mot) ) { // si la map indexe déjà le mot
     map.put(mot, map.get(mot) + 1); // incrémenter le compteur associé
} else { // le mot n'a jamais été encore compté puisqu'il n'est pas encore dans la map
     map.put(mot, 1); // ajouter le mot dans la map et le compter 1 fois 
}

Ensuite, tu peux lire les valeurs dans ta map pour déterminer par exemple ceux qu'on retrouve le plus grand nombre de fois par exemple :

Code :

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

1
2
3
4
5
int max=0;
for(Integer valeur : map.values()) { // on parcourt tous les compteurs
   if( valeur>max ) max = valeur; // si la valeur est supérieur au max courant, c'est qu'elle est forcément plus possiblement le max;
}
// maintenant dans max on a forcément la plus grande des valeurs, c'est à dire le plus grand nombre de fichiers qui contient un même mot

Puis chercher dans ta map les mots dont le compteur associé est égal au max trouvé :

Code :

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

1
2
3
4
5
6
7
8
9
10
for(Map.Entry<String, Integer> entry : map.entrySet()) { // on parcourt toutes les entrées (comprends associations clef-valeur)
 
    if ( entry.getValue()==max ) { // si cette entrée  est égale au max
      String mot = entry.getKey(); // on lit le mot correspondant au compteur qui est égal au max
       // le mot contenu dans la variable mot est un mot contenu dans un nombre de fichier qui correspond au plus grand nombre de fichier qui stocke un même mot
      // et là tu fais ce que tu veux avec ce mot
      // tu le stocke dans une liste, tu l'affiches, tu l'écris dans fichier, que sais-je ... 
    }
 
}

[mimihh]

Merci infiniment un grand merci vraiment
mais je voulais savoir si je pourrais avoir les 5 mots ayant les valeurs max c'est à dire les 5 premiers qui apparaissent dans la majorités des fichiers

[joel.drigo]

Merci infiniment un grand merci vraiment

pas de quoi

mais je voulais savoir si je pourrais avoir les 5 mots ayant les valeurs max c'est à dire les 5 premiers qui apparaissent dans la majorités des fichiers

Dans la map, à la fin, tu as tous les comptes, donc tu peux oui.

Par exemple, tu cherches d'abord les 5 valeurs max : tu peux par exemple trier les valeurs de la map en ordre décroissant et prendre les 5 premières (tu peux faire ça par exemple en mettant les valeurs (map.getValues()) dans un TreeSet avec un comparateur (java.util.Comparator) qui tri en décroissant...

Le TreeSet va garantir qu'en plus chaque valeur de compteur ne figure qu'une seule fois

quelque chose comme ça :

Code :

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

1
2
3
4
5
6
Set<Integer> plusgrandaupluspetitSet = new TreeSet<Integer>(new Comparator<Integer>() { 
                        public int compare(Integer i1, Integer i2) {
                            return -i1.compareTo(i2); // -1 pour avoir l'ordre décroissant
                       }
)};
plusgrandaupluspetitSet.addAll(map.values()); // on met dans ce TreeSet tous les compteurs se trouvant dans la map

Ensuite : tu parcours ce treeset avec un compteur de mots (qui ne doit pas dépasser 5 donc) :

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
int maxmot=0;
for(Iterator<Integer> iter = plusgrandaupluspetitSet.iterator(); maxmot<5 && iter.hasNext(); ) { // on parcourt les compteurs du plus grand au plus petit, en se limitant à 5 mots max
   int max=iter.next();
   // la on fait exactement pareil qu'avant, mais en veillant à ne pas dépasser 5 mots max
   for(Iterator<Map.Entry<String, Integer>> entryIter = map.entrySet().iterator(); maxmot<5 && entryIter.hasNext();) { // on parcourt toutes les entrées (comprends associations clef-valeur) en se limitant à 5 mots max
 
       Map.Entry<String, Integer> entry = entryIter.next();
       if ( entry.getValue()==max ) { // si cette entrée  est égale au max
            String mot = entry.getKey(); 
 
      ... 
 
           maxmot++; // on compte ce mot
      }
      // ici on va reboucler alors qu'on est sûr d'avoir bien sélectionné tous les mots (mais pas plus de 5 en tout) qui se trouvait dans "max" fichiers..., 
   }
 
}

On pourrait également trier la map en ordre décroissant sur les compteurs (il faut rendre map final), mais je sais pas , j'aime moins cette solution :

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
Map<String, Integer> maptriee = new TreeMap<String, Integer>(new Comparator<String>() {
     public int compare(String mot1, String mot2) {
         Integer compteurmot1=map.get(mot1);
         Integer compteurmot2=map.get(mot2);
         return -compteurmot1.compareTo(compteurmot2); 
     }
});
maptriee.putAll(map); // on mets toutes les associations de map dans maptriee
//puis prendre les 5 premières valeurs :
int maxmot=0;
for(String mot : maptriee.keySet()) {
     ...
     maxmot++;
     if ( maxmot==5 ) break; // on a trouvé 5 mots, on s'arrête
}