Discussion :

[cheyma]

Bonsoir,


J'ai un fichier texte (il contient un mot sur chaque ligne), je parcours ce dernier et à chaque ligne je fais un traitement sur ce mot. Puis, je transforme ce mot en une suite de sous mot (dans une liste: ArrayList<String> )
D'autre part j'ai une map qui contient l'ensemble de sous chaine de tout le fichier LinkedHashMap<String, Integer[]> = une chaine (key) + un tableau d'entier.

Mon objectif , c'est de parcourir ces deux structures de données (map et liste), pour chaque sous chaine de la liste , je cherche son existance dans le map. Un compteur s'incrémente et un calcul se fait (le produit des trois fonctions mentionnées)pour chaque sous mot.

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
 
public static void GenerationFicher(String fichier, int x, LinkedHashMap<String, Integer[]> m, BufferedWriter pw) throws FileNotFoundException, IOException {
        ArrayList<String> motExtré = new ArrayList<>();
        Scanner sc = new Scanner(new File(fichier));
        String s = "";
        while (sc.hasNextLine()) {
            String line = sc.nextLine();
            String mot = sousChaine(line);
            motExtré = ExtraNgram(mot, x);
            String ss = "";
            int compteurGram = 1;
            //comparer le contenu de la liste et de la map
            for (String me : motExtré) {
                for (Map.Entry<String, Integer[]> e : m.entrySet()) {
                    if (me.equals(e.getKey())) {
                        s = compteurGram + ":" + (nbrFqGram(mot, me) * chiffreGram(me) * positionGram(mot, me));
                        compteurGram++;
 
                    }
                    ss = ss + " " + s;
                }
                ss = target(line) + ss + " #" + mot;
                pw.write(ss);
                pw.newLine();
            }
 
        }
 
    }

Mon problème c'est que le traitement éffectué se fait seulement pour la première sous chaine du mot (dans notre cas la taille de sous chaine =1)
la taille peut vari entre 1 et 3 carcatères.

Pour chaque ligne du fichier : par exemple pour le mot: bjr
Résultat souhaîté: -1 1:2 2:4 3:1 #bjr
Résultat obtenu: -1 1:2 #bjr
Donc le traitementest fait seulement pour le prmier gram (dans nore cas 1 seul caracteres) --> b

Merci de m'aider à resoudre ce problème (normalement il réside au niveau de l'une des boucles for)

[joel.drigo]

Salut,

1. 
   Premièrement, si on observe ça :
   

   Code :

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

   1
   2
   3
   4
   5
   6
   7
   8
   9
    
    for (Map.Entry<String, Integer[]> e : m.entrySet()) {
                       if (me.equals(e.getKey())) {
                           s = compteurGram + ":" + (nbrFqGram(mot, me) * chiffreGram(me) * positionGram(mot, me));
                           compteurGram++;
    
                       }
                       ss = ss + " " + s;
                   }

   On voit que s est concaténé à ss à chaque tour de boucle, donc autant de fois qu'il y a d'entrées dans la map. "s" est initialisé au début, avant même de commencer à lire le fichier : on va donc voir des valeurs qui se répètent d'autres lignes, et d'autres mots, le tout imbriqué.
   
   Par ailleurs, un map, c'est un composant qui sert à associer des clefs et des valeurs, et ça sert à ça en premier lieu, sinon tu fais un tableau de couples ! Donc utilise get() au lieu de systématiquement parcourir les entrées et faire du equals.
   
   Et utilise un StringBuilder au lieu d'une concaténation pour ss, ou mieux, écrit directement dans le writer comme je te l'ai déjà dit.
2. Ce qui me semble étrange dans ton code c'est ça :
   

   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
    while (sc.hasNextLine()) {
               String line = sc.nextLine();
               String mot = sousChaine(line);
               motExtré = ExtraNgram(mot, x);
               String ss = "";
               int compteurGram = 1;
               //comparer le contenu de la liste et de la map
               for (String me : motExtré) {
                   for (Map.Entry<String, Integer[]> e : m.entrySet()) {
                       if (me.equals(e.getKey())) {
                           s = compteurGram + ":" + (nbrFqGram(mot, me) * chiffreGram(me) * positionGram(mot, me));
                           compteurGram++;
    
                       }
                       ss = ss + " " + s;
                   }
                   ss = target(line) + ss + " #" + mot;
                   pw.write(ss);
                   pw.newLine();
               }
    
           }

   Regarde les niveaux de boucles : n'y a-t-il rien qui te gêne au niveau logique ? Si tu as plusieurs String dans motExtré, tu devrais avoir plusieurs lignes dans ta sortie avec le même suffixe "#mot" !
   Tu dis vouloir obtenir "-1 1:2 2:4 3:1 #bjr". Si tes données sont censées produire ça, tu obtiendras plutôt un truc dans le genre :
   

   -1 1:2 #bjr
   -1 -1 1:2 #bjr 2:4 #bjr
   -1 -1 -1 1:2 #bjr 2:4 #bjr 3:1 #bjr

   Il faut faire attention à ces niveaux de boucle : traiter ce qui doit être traiter au bon niveau de boucle. Dans le bloc, ça se répète, hors du bloc, ça ne se répète pas.
   Si tu as une structure :
   

   Code :

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

   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   { // début de bloc
    
           déclaration variable1
           déclaration variable2
    
           répéter 10 fois {
                   afficher variable1
           }// fin répéter
    
           afficher variable2
    
   } // fin de bloc

   Tu verras 10 fois ta variable varaible1, et une fois ta variable2.

Ton programme devrait en toute logique être comme ça :

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
public static void GenerationFicher(String fichier, int x, LinkedHashMap<String, Integer[]> m, BufferedWriter pw) throws FileNotFoundException, IOException {
         Scanner sc = new Scanner(new File(fichier));
        while (sc.hasNextLine()) {
            String line = sc.nextLine();
            String mot = sousChaine(line);
            List<String> motExtré = ExtraNgram(mot, x);
            int compteurGram = 1;
            //comparer le contenu de la liste et de la map
            pw.write( String.valueOf(target(line)) ); // line est déclarée dans ce bloc, target(line) n'apparaitra donc que dans une ligne de sortie
            for (String me : motExtré) {
                if ( m.containsKey( me ) {
                        String s = compteurGram + ":" + (nbrFqGram(mot, me) * chiffreGram(me) * positionGram(mot, me));
                        compteurGram++;
                        pw.write(" ");
                        pw.write(s); // et encore on pourrait se passer de s
                }
            }
            pw.write(" #");
            pw.write(mot); // mot est déclarée dans ce bloc, il n'apparaitra donc que dans une ligne de sortie
            pw.newLine();
 
        }
 
    }

Si avec ça tu n'obtiens pas "-1 1:2 2:4 3:1 #bjr", le problème vient des données

[cheyma]

Bonsoir,

Merci pour votre réponse
Oui je me trompe beacoups quand j'ai de boucles imbriquées. Merci pous vos conseils.

Mais ça n'a pas marché.. encore la même structure du fichier résultat.

Sinon, pour 2- Oui c'est exprès , vue que je manipule mes données d'entrée à partir du fichier et je les transforme à une suite de valeurs (une sorte de codification) donc je mets la variable #mot pour marquer le mot courant. Donc c'est logique.

Pour la map il contient des valeurs non redendantes

Si je veux changer un peu la logique ...
Si je parcours la liste , et pour chaque valeur je la cherche dans le map si je la trouve j'écris son encodage qui se trouve dans le 2éme élement du Ineger[] suivie par la valeur retourné par le produit de 3 fonctions.

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
 
 public static void GenerationFicher(String fichier, int x, LinkedHashMap<String, Integer[]> m, BufferedWriter pw) throws FileNotFoundException, IOException {
        ArrayList<String> motExtré = new ArrayList<>();
        Scanner sc = new Scanner(new File(fichier));
        while (sc.hasNextLine()) {
 
            String line = sc.nextLine();
            String mot = sousChaine(line);
            motExtré = ExtraNgram(mot, x);
            //chercher la valeur de chaque case de la liste dans le map
 
            pw.write(String.valueOf(target(line))); // line est déclarée dans ce bloc, target(line) n'apparaitra donc que dans une ligne de sortie
            for (String me : motExtré) {
                for (Map.Entry<String, Integer[]> e : m.entrySet()) {
                    if (e.getKey().equals(me)) {
                        Integer[] tab = e.getValue(); // acceder au deuxième élement de Integer[]
                        int c = tab[1];
                        String compteurGram = Integer.toString(c);
                        String s = compteurGram + ":" + (nbrFqGram(mot, me) * chiffreGram(me) * positionGram(mot, me));
                        pw.write(" ");
                        pw.write(s); // et encore on pourrait se passer de s
                    }
                }
                pw.write(" #");
                pw.write(mot); // mot est déclarée dans ce bloc, il n'apparaitra donc que dans une ligne de sortie
                pw.newLine();
 
            }
 
        }
}

Merci pour votre aide

[joel.drigo]

Pour la map il contient des valeurs non redondantes

Les clefs le sont forcément dans une map. Mais ça ne change rien à ce que j'ai dit.

Non :

Code :

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

1
2
3
 
                for (Map.Entry<String, Integer[]> e : m.entrySet()) {
                    if (e.getKey().equals(me)) {

ça ne sert à rien de faire ça comme çà! J'ai déjà dit pourquoi. On fait if ( m.containsKey(me) ), ou Integer[] tab=e.get(me); if ( tab!=null)... ! Justement parce qu'une clef est unique.

Code :

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

1
2
3
4
5
6
7
for (String me : motExtré) {
                /*... un me une seul fois dans la map = un seul compteur */
                pw.write(" #");
                pw.write(mot); // mot est déclarée dans ce bloc, il n'apparaitra donc que dans une ligne de sortie
                pw.newLine();
 
            }

Donc, pour chaque me de motExtré, tu ne pourras obtenir qu'au plus une ligne, avec #mot à la fin et un seul compteur dedans.

Code :

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

1
2
pw.write(String.valueOf(target(line))); // line est déclarée dans ce bloc, target(line) n'apparaitra donc que dans une ligne de sortie
            for (String me : motExtré) {

En revanche, on a bien une target par ligne du fichier, donc par ligne du fichier on obtiendra au mieux :

target(line)
tab[1]:calcul #mot
tab[1]:calcul #mot
tab[1]:calcul #mot

ou si tous les me ne sont pas dans la map

target(line)
tab[1]: calcul #mot
#mot
tab[1]: calcul #mot

Pas la peine de faire :

Code :

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

1
2
String compteurGram = Integer.toString(c);
String s = compteurGram + ":" + (nbrFqGram(mot, me) * chiffreGram(me) * positionGram(mot, me));

La conversion étant implicite :

Code :

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

1
2
 
String s = c + ":" + (nbrFqGram(mot, me) * chiffreGram(me) * positionGram(mot, me));

[cheyma]

Bonsoir,

Je n'ai pas bien compris les exemples que vous avez mentionnés.
Pour clarifier de plus le resultat attendu,

- j'ai un fichier contenant une liste de mots (chaque mot se trouve dans une ligne)
- j'ai une map contenant tous les n-gramme (l'ensemble de sous mot , c'est la contacétnation de 1/2/3 caractère succésiffs) sans redandance. Ces sous mots présentent le key. et un tableau de taille 2 (Integer[]) dans le 2éme élement , jai ossocié un compteur qui présente un code pour chaque key (gramme).
- Mon objectif c'est:
** Parcourir mon fichier de mot donné (ligne par ligne c-à-d mot par mot)
** Chaque mot je le découpe en sous mot (taille est parametrée (1/2/3)). Ces sous mot (grammes), je les mets dans une liste.
** Chaque sous mot (case de la liste) je le cherche dans la map.
** Si je le trouve (peut-être oui peut-être non) , j'écris dans mon fichier résultat: la valeur associée au (key= gramme courant) : suivie par la valeur (produit de 3 valeurs) et ainsi de suite pour tous les grammes .. à la fin de la ligne (mot courant) je met #le mot.

Voila c'est ce que j'ai fait avec ma fonction GenerationFichier.

merci pour votre compréhension et votre patience

[joel.drigo]

Code :

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

1
2
for (Map.Entry<String, Integer[]> e : m.entrySet()) {
                    if (e.getKey().equals(me)) {

Est-ce que tu comprends que comme une clef ne peut être qu'une seule et une seule fois dans une map, la condition du test (if) ne pourra être vraie qu'une seule fois au plus ?

[cheyma]

Bonjour,

Oui je comprends la structure de donnée map, déja elle est remplie via une autre fonction dont le but de sauvegarder mes données sans redandance.
J'ai mis ce test de if, pour chercher le key et vérifier la condiction d'éxistance de la valeur courante de me (une case de la liste) dans le map.

C'est faux de tester comme ça ?


Merci

[joel.drigo]

Ce n'est pas faux, c'est juste inefficace : une hashmap est optimisée pour l'accès par clef, autant utiliser cet accès (par containsKey(), ou get()).

Mais là n'est pas le problème : le problème que tu poses (ta question d'origine) c'est que tu estimes pouvoir avoir un résultat avec plusieurs compteurs dans une ligne, alors que c'est impossible avec ton code. Comme la condition ne peut être vraie qu'une fois au plus, il ne peut y avoir qu'un seul "compteur" au plus, et juste après ta boucle (sur les entrées de la map), tu fais :

Code :

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

1
2
3
4
 
pw.write(" #");
pw.write(mot); // mot est déclarée dans ce bloc, il n'apparaitra donc que dans une ligne de sortie
pw.newLine();

tu écris "#mot" puis tu passes à la ligne. Donc il est impossible d'avoir plusieurs compteurs sur une ligne, quelque soit tes données. Il ne peut y avoir qu'un compteur au plus avec #mot derrière par ligne dans ta sortie.

[cheyma]

Je voudrais avoir un seul compteur par ligne.
Et à la ligne qui suit, je remet le compteur á 0 et rebelote .
Je dois changer la structure de donnée par exemplerpour stocker les valeurs?

[joel.drigo]

Je ne comprends plus rien ! Ce n'est pas ce que tu demandais à l'origine !

Résultat souhaîté: -1 1:2 2:4 3:1 #bjr
Résultat obtenu: -1 1:2 #bjr

[cheyma]

Bonsoir

Excusez-moi oui j'ai voulu traité la fonction par deux méthodes.
au premier lieu :

Résultat souhaîté:
-1 1:2 2:4 3:1 4:2 5:1 6:6 7:4 #bonjour
-1 1:4 2:3 3:8 4:1 #allo
------------------------------------------------------------------------------------------------------------
Résultat obtenu:
-1 1:2 #bjr
-1 1:4 #allo

j'ai déclaré un compteur qui s'incrémente à chaque calcul du produit (compteur pour chaque ligne). Même avec ce code (ci-dessous) j'ai obtenu le mêm resulat.

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
 
public static void GenerationFicher(String fichier, int x, LinkedHashMap<String, Integer[]> m, BufferedWriter pw) throws FileNotFoundException, IOException {
        Scanner sc = new Scanner(new File(fichier));
        while (sc.hasNextLine()) {
            String line = sc.nextLine();
            String mot = sousChaine(line);
            List<String> motExtré = ExtraNgram(mot, x);
            int compteurGram = 1;
            //comparer le contenu de la liste et de la map
            pw.write(String.valueOf(target(line))); // line est déclarée dans ce bloc, target(line) n'apparaitra donc que dans une ligne de sortie
            for (String me : motExtré) {
                if (m.containsKey(me)) {
                    String s = compteurGram + ":" + (nbrFqGram(mot, me) * chiffreGram(me) * positionGram(mot, me));
                    compteurGram++;
                    pw.write(" ");
                    pw.write(s); // et encore on pourrait se passer de s
                }
            }
            pw.write(" #");
            pw.write(mot); // mot est déclarée dans ce bloc, il n'apparaitra donc que dans une ligne de sortie
            pw.newLine();
 
        }
 
    }

Puis j'ai changé un peu la logique, les mêmes données et le traitement sauf que au lieu d'incrémenter un compteur et de l'écrire dans mon fichier resultat. J'écris la valeur courante de la liste si ça exsiste dans la map.

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
 
public static void GenerationFicher(String fichier, int x, LinkedHashMap<String, Integer[]> m, BufferedWriter pw) throws FileNotFoundException, IOException {
 
    ArrayList<String> motExtré = new ArrayList<>();
        Scanner sc = new Scanner(new File(fichier));
        String s="";
        while (sc.hasNextLine()) {
 
            String line = sc.nextLine();
            String mot = sousChaine(line);
            motExtré = ExtraNgram(mot, x);
            String ss = "";
            //comparer le contenu de la liste et du map
            for (Map.Entry<String, Integer[]> e : m.entrySet()) {
                for (String me : motExtré) {
                    if (e.getKey().equals(me) == true) {
                        Integer[] tab = e.getValue(); // acceder au deuxième élement de Integer[]
                        int c = tab[1];
                        String compteur = Integer.toString(c);
                        s = compteur + ":" + (nbrFqGram(mot, me) * chiffreGram(me) * positionGram(mot, me));
                    } 
                    ss = ss + " " + s;
                }
            }
            ss = target(line) + ss + " #" + mot;
            pw.write(ss);
            pw.newLine();
 
        }
 
    }

Résultat souhaîté:
-1 25:2 63:4 13:2 24:2 5:6 16:4 71:4 #bonjour
-1 11:4 82:3 100:8 54:4 #allo
------------------------------------------------------------------------------------------------------------
Résultat obtenu:
Un fichier composé de caractères chinois

Merci et Pardon

[cheyma]

Re

Voila c'est prsq résolu
le résultat attendue est affichée correctement ... Sauf que je n'ai pas pu l'écrire dans un fichier texte.
J'ai obtenu un fichier vide et encodé sous ANSI malgré que j'ai fixé l'encodage à UTF-8.
Merci pour m'aider à resoudre le problème de l'écriture dans le fichier.
Est ce que vous me proposez un autre flux au lieu de:

Code :

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

1
2
 
BufferedWriter fichResUni = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("chemin/fichier.txt"), "UTF-8"));

Fonction réctifiée:

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
 
public static void GenerationFicher(String fichier, int x, LinkedHashMap<String, Integer> m, BufferedWriter pw) throws FileNotFoundException, IOException {
 
        Scanner sc = new Scanner(new File(fichier));
        String s = "";
        while (sc.hasNextLine()) {
            ArrayList<String> motExtré = new ArrayList<>();
            String line = sc.nextLine();
            String mot = sousChaine(line);
            //System.out.println("********MOT*****" + mot);
            gnerationNGrams(motExtré, mot, x);
            String ss = "";
            //comparer le contenu de la liste et du map
            for (Map.Entry<String, Integer> e : m.entrySet()) {
                for (String me : motExtré) {
                    if (e.getKey().equals(me) == true) {
                        String compteur = Integer.toString(e.getValue());
                        s = compteur + ":" + (nbrFqGram(mot, me) * chiffreGram(me) * positionGram(mot, me));
                        ss = ss + " " + s;
                    }
 
                }
            }
            ss = target(line) + ss + " #" + mot;
            System.out.println(ss);
            pw.write(ss);
            pw.newLine();
 
        }
    }

Résultat:

[joel.drigo]

Qu'est-ce qui te fait dire que ton fichier serait encodé en ANSI (Win1253 ou ISO-8859-1 plutôt non ?) ? Si c'est parce que tu l'ouvres dans je ne sais quel éditeur qui te dirait ça, ça ne veut rien dire... Simplement, comme il n'y a pas de BOM par défaut, aucun éditeur ne saura détecter forcément que l'encodage est UTF-8, surtout s'il ne contient pas de code uniquement UTF-8 (s'il ne contient que du ASCII par exemple (ASCII étant un sous-ensemble de UTF-8)).

En tout cas, ta création de BufferedWriter est la bonne manière pour générer un fichier UTF-8 (tu pourrais faire plus simple avec Files.newBufferedWriter(Paths.get("chemin/fichier.txt"), StandardCharsets.UTF_8);, mais ça donnerait la même chose).

[cheyma]

Avec la fonction précédement citée et à travers le flux BufferedWriter, j'ai otenu un fichier vide encodé ANSI
J'utilise l'éditeur notepad





Merci

[joel.drigo]

C'est bien ce que je te disais : ce n'est pas parce que tu vois ANSI dans ton dialogue de notepad que ton fichier est "ANSI", surtout que là, tu montres la sauvegarde, où on choisi l'encodage qu'on veut pour l'enregistrement, donc rien à voir avec l'encodage du fichier d'origine.

Si ton fichier est vide, c'est possiblement parce que tu ne fermes pas le flux (donc aucun flush n'est fait, donc le buffer n'est pas vidé dans le fichier).

Code :

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

1
2
3
try(BufferedWriter fichResUni = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("chemin/fichier.txt"), "UTF-8"))) {
    GenerationFicher(input, x,  m, fichResUni);
}

D'ailleurs, je t'avais déjà dit que tu ne fermais pas ton flux en lecture (le Scanner) !!! Ce n'est toujours pas le cas.

[cheyma]

Merci

fichResUni.close();
fichResUni.flush();

C'est

[joel.drigo]

Je n'ai JAMAIS écrit de faire ça :

fichResUni.close();
fichResUni.flush();

Fermer (close) le flux le vide (flush) d'office. Donc si tu fermes, inutile de le vider. Surtout après l'avoir fermé !

Je t'ai donné le code à écrire, avec un try-with-resource !!! Pourquoi faut-il que tu fasses systématiquement autre chose (parce que c'est déjà comme ça que tu as fait tout au long de ce fil) ? A la fin, ça finit par tomber en marche, mais c'est bancal, innéfficace, inutilement compliqué et, souvent, en dépit de toute logique.

[cheyma]

Bonsoir

Oui oui c'est ce que j'ai fait , j'ai ajouté le try , de plus j'ai fermé et j'ai vidé le flus au niveau de l'appel de la fonction, dans mon cas c'est au niveau main.

Merci pour vos conseils