Comparer plusieurs fichiers

Version imprimable

19/10/2013, 22h10
mimihh

Comparer plusieurs fichiers

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.
19/10/2013, 23h27
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.
20/10/2013, 00h45
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

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:

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:

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:

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:

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 ... } }

20/10/2013, 02h23
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

Citation:

Envoyé par mimihh

Merci infiniment un grand merci vraiment

pas de quoi :)

Citation:

Envoyé par mimihh

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:

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:

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:

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 }

20/10/2013, 17h00
mimihh

Merci pour ton effort et toutes ces explications mais comment puisse je afficher les 5 mots ayant les 5 premiers valeurs ?
Prière de m'excuser pour ce dérangement. Merci encore une fois
20/10/2013, 17h13
joel.drigo

Citation:

Envoyé par mimihh

Merci pour ton effort et toutes ces explications mais comment puisse je afficher les 5 mots apparaissant dans les 5 premiers valeurs maximum?
Prière de m'excuser pour ce dérangement. Merci encore une fois

Euh, ma reponse précédente répond à cette question :roll: enfin si chaque mot est dans un nombre de fichiers différent évidemment, sinon tu ne peux avoir 5 mots pour les 5 valeurs max (si 2 mots apparaissent le nombre de fois max par exemple (et les 3 mots suivant un nombre différent), il ne peut y avoir de mot dans la 5ième valeur max forcément).

Si c'est l'affichage en lui même que tu me demandes, c'est

Code:

System.out.println(mot);

pour afficher dans la console...
c'est ça la réponse que tu attends 8O
20/10/2013, 17h29
mimihh

Moi je voulais afficher les mots qui apparaissent dans la plupart des fichier par exemple si j'ai 10 fichiers et j'ai 50 mots distribués sur ces différents fichiers, et j'ai une suite de nombre désignant le nombre de fichiers où une mot apparaissait par exemple:
voiture n = 5
arbre n = 48
garçon n= 25
porte n= 2
fille n = 10
maison n = 44
avion n = 22
chat n = 32
monstre n =13
le programme doit donner les mots suivants: arbre, maison, chat, garçon, avion

bon j'ai essayer ce code:

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
 
              for( i=0;i<list4.length;i++){
            if ( map.equals(list4[i]) ) { // si la map indexe déjà le mot
            map.put(list4[i], map.get(list4[i]) + 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(list4[i], 1); // ajouter le mot dans la map et le compter 1 fois 
            }
         }
 
 
 
  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
     System.out.println(mot);
}
 
         }
 
}
}

bon list4[i] designe un mot i existant dans un fichier car j'ai mis le contenu de chaque fichier dans une liste noté list4
mais il me donne comme output
null
null
null
...

Salut,

déjà à la place de

Code:

if ( map.equals(list4[i]) )

en ligne 3

c'est

Code:

if ( map.containsKey(list4[i]) )

parce qu'en je le suppose list4 étant un tableau de String, une map ne pouvant être égale à une String, tous tes compteurs sont à 1 avec ton code.

ensuite :
Code:

1 2 3 4 5 for(String mot : maptriee.keySet()) { System.out.println(mot); maxmot++; if ( maxmot==5 ) break; // on a trouvé 5 mots, on s'arrête }
essaye déjà d'afficher maptriee avant ce for pour voir ce qu'elle contient

tu es sûr que list4 contient bien des mots ?
affiches son contenu pour en être sur (ou map après l'avoir construite)

En tout cas, si je fais le test de mon côté je n'ai pas de problèmes, ça fonctionne.. y'a juste que comme tu as pris le second exemple (que j'aime le moins donc), tu ne pourras pas te servir de la TreeMap pour retrouver tes comptes de mots par maptriee.get(mot) (d'ailleurs ça m'interesse de comprendre pourquoi par ailleurs): il faudra parcourir les entries :
Code:

1 2 3 4 5 6 int maxmot=0; for(Map.Entry<String, Integer> entry : maptriee.entrySet()) { System.out.println(entry.getKey() + " trouvé " + entry.getValue() + " fois"); maxmot++; if ( maxmot==5 ) break; // on a trouvé 5 mots, on s'arrête }
Par contre il y une erreur dans mon code : je n'avais pas pensé au cas ou 2 mots se trouveraient dans autant de fichiers :oops: (pourquoi quand je donne des exemples de codes, dont je dis qu'un me plait moins ou que c'est de la bidouille..., on prend toujours celui là à chaque fois 8O)

Il faut donc que modifier le comparateur :
Code:

1 2 3 4 5 6 7 8 9 10 11 new Comparator<String>() { public int compare(String mot1, String mot2) { Integer compteurmot1 = map.get(mot1); Integer compteurmot2 = map.get(mot2); int compare = compteurmot1.compareTo(compteurmot2); if ( compare==0 ) { return -1; // si le nombre de fichiers est le même l'ordre importe peu : on conserve l'ordre actuel } return -compare; // - pour ordre décroissant } });

Citation:

Envoyé par joel.drigo

(d'ailleurs ça m'interesse de comprendre pourquoi par ailleurs)

je me répond à moi même parce que j'ai tilté dans l'intervalle ;) voilà peut être par intuition pour ça me plaisait pas :P

la recherche par clef dans une TreeMap s'opère par le comparateur, et comme le comparateur ne renvoit pas 0 pour 2 mots égaux, ça foire...

voici le code final du comparateur :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 new Comparator<String>() { public int compare(String mot1, String mot2) { int compare; if ( mot1.equals(mot2) ) { compare = 0; // même mot, égalité } else { Integer compteurmot1 = map.get(mot1); Integer compteurmot2 = map.get(mot2); compare = compteurmot1.compareTo(compteurmot2); if ( compare==0 ) { compare = -1; // même compte de fichiers, on distingue les 2 mots } else { compare = -compare; // on inverse l'ordre pour être décroissant } } return compare; } });

20/10/2013, 23h16
mimihh

Exception in thread "main" java.lang.NullPointerException dans les trois lignes suivantes :
if ( mot1.equals(mot2) ) {
new Comparator<String>() {
maptriee.putAll(map);

:cry: :oops: :oops:

Citation:

Envoyé par mimihh

Exception in thread "main" java.lang. NullPointerException dans les trois lignes suivantes :

tu dois savoir ce que ça veut dire NullPointerException, non ?

Citation:

Envoyé par mimihh

if ( mot1.equals(mot2) ) {

donc c'est qu'il y a des valeurs null dans ta liste de mots : à quoi ça sert d'avoir des valeurs null dans ta liste de mots ? soit tu construis ta liste de mots correctement, soit tu évites d'ajouter ces null dans map au moment du comptage !

Citation:

Envoyé par mimihh

new Comparator<String>() {

euh là NullPointerException dans cette ligne ? 8O m'est avis que c'est une mauvaise interpretation de la stacktrace

Citation:

Envoyé par mimihh

maptriee.putAll(map);

euh, maptriee n'est pas null, si ? ce serait pas encore une mauvaise interprétation de la stacktrace, et qu"en fait c'est la même npe qui est dans le test dans le comparateur ?
si tu as des clefs null dans map, c'est normal... mais de nouveau pourquoi chercher à compter des null ?

Garbage in, garbage out!

On peut bien sûr protéger contre les null en ajoutant des tests et en s'arrangeant pour que les nulls soient envoyés vers la fin de la liste, mais autant ne pas mettre de mots null dans ta liste de mots !!!
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 new Comparator<String>() { public int compare(String mot1, String mot2) { int compare; if ( mot1==null || mot2==null ) { if( mot1==mot2 ) { compare=0; } else if ( mot1==null ) { compare=1;// on envoit les null vers la fin } else { // donc mot2==null compare=-1;// on envoit les null vers la fin } } else if ( mot1.equals(mot2) ) { compare = 0; // même mot, égalité } else { Integer compteurmot1 = map.get(mot1); Integer compteurmot2 = map.get(mot2); compare = compteurmot1.compareTo(compteurmot2); if ( compare==0 ) { compare = -1; // même compte de fichiers, on distingue les 2 mots } else { compare = -compare; // on inverse l'ordre pour être décroissant } } return compare; } });
Enfin tout ça c'est le béaba... protéger un programme contre des npe... ou s'arranger pour avoir des données à traiter qui ne soit pas pourries :roll:

21/10/2013, 00h32
mimihh

ok merci beaucoup joel.drigo ça marche pour le moment c très gentil vraiment
je vais essayer de vérifier si les 5 mots extraits par ce programme sont ceux qui apparaissent plus dans la majorité des fichiers.
Mille merci.