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
}

[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

[joel.drigo]

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 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 :

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

System.out.println(mot);

pour afficher dans la console...
c'est ça la réponse que tu attends

[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

[mimihh]

bon j'ai essayer ce code:

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

[joel.drigo]

Salut,

déjà à la place de

Code :

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

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

en ligne 3

c'est

Code :

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

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 :

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

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 :

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

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 (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 )

Il faut donc que modifier le comparateur :

Code :

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

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

[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

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 :

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

[mimihh]

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

[joel.drigo]

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

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

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 !

new Comparator<String>() {

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

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 :

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

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