Discussion :

[cheyma]

Bonsoir tout le monde ,

Je suis entrain de developper la méthode de calcul de cosinus dans l'espace vectoriel , en fait à ce niveau lâ je programme une méthode qui accepte comme paramêtres deux fichiers en mode lecture et une martice à remplir. D'ou je vais remplir ma matrice par ces deux fichiers. Sauf que mes fichiers ont la structure suivante : mot de 3 caractère + deux points + entier, exemple ---> abc:25

Pourriez vous m'aider à réaliser ce traitement ?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
public static void remplissage(BufferedReader f1,BufferedReader f2 ,String[][] matrice ) throws IOException
{ 
    String c = null;
         while ((c = f1.readLine()) != null) {
            String[] ligne = c.split(":");
            String gram=ligne[0];
            int Fq = Integer.parseInt(ligne[1]);
           // Je vousdrais remplair les cases de la matrice
 
        }
}

Ma matrice resultat devient être comme suit :

abc 12 0
bfj 26 0
hdy 2 5
hdt 12 2
ghu 0 152


Aidez-moi s'il vous plaît

[Gannox]

Bonjour,

La matrice est censée contenir uniquement des String donc il faudra parse les entiers de chaque ligne.

Pour le remplissage, à vue de nez, si j'essaye de m'adapter à ce qui a déjà été fait, je mettrais les lignes suivantes dans le while :

Code :

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

1
2
3
4
5
6
for(int i = 0; i < matrice.length; i++) {
    String[] ligne = c.split(":");
    matrice[i][0] = ligne[0];
    matrice[i][1] = ligne[1];
    matrice[i][2] = ligne[2];
}

[Alkhan]

Bonjour,
Déjà, on ne va pas faire le boulo à ta place !
tu n'explique pas assez ce que tu veux faire, mais si je ne me trompe pas, les valeurs de la colonne 2 viens du fichier 1 et les valeurs de la colonne 3 du fichier 2 ?

Premièrement, as tu vraiment besoin de faire un tableau, ou tu peux utiliser autre chose comme structure ?
Ton problème dans un premier temps est que tu es incapable de connaître le nombre de ligne sans avoir parcouru l'ensemble de tes fichiers !
Le deuxième problème est que si 'abc' existe dans les deux fichiers alors tu dois pouvoir le rechercher pour mettre sa deuxième valeur !

Conclusion l'utilisation d'une Collection tel qu'une Map serait plutôt adapter !

Maintenant, il faut voir ce que tu va mettre comme values dans la Map !
Si tu n'as pas vraiment besoin d'une matrice alors pourquoi ne pas créer un objet qui contiendra tes valeurs et ta chaine qui il me semble correspondra à ton angle et tu pourra y ajouter la méthode qui te retournera le cosinus.

Si tu a vraiment besoin d'une matrice alors, tu y met un tableau a 3 éléments et ensuite tu reconstruis ta matrice lorsque tu as toute les valeurs.

Pour finir, il n'est pas utile de passer la matrice à la méthode remplissage car tu ne peux pas connaître sa taille avant d'avoir lu les fichiers !

[cheyma]

Bonjour,

Je vous remercie pour votre réponses.

En fait j'ai deux fichiers (f1 et f2) chaque ligne de ces deux derniers a la structure --> mot : entier , par exemple abc:15 , dans le même fichier ce mot est unique (c_à-d je peux pas trouver encore un abc:entier) par contre dans f2 je peux y trouver.

En fait je suis un peu hésitée pour le choix de la structure de données matrice , et comme première impression je trouve que celle la plus adaptable pour ensuite comparer deux vecteurs.

A ce niveau la Je pense à:
1) Remplir la matrice M par toutes les lignes du fichier f1 (vue qu'il y a pas de redandance des lignes et vu aussi que le f1 a la plus grande taille) {f1: 7702 lignes et f2: 6017}
Normalement ma matrice sera formée par (7702+6017) lignes et 3 colonnes (colonne 1 contient le mot - colonne 2 contient la fq du mot dans f1 - colonne 3 contient la fq du mot dans f2)

un petit exemple :
abc 15 0
sgh 6 0
g3_ 3 0
.... (jusqu'à la fin fichier f1)

2) Parcourir la matrice déja remplie, et ouvrir le ficher f2 en mode écriture. Quand je trouve un mot de matrice existe dans le f2 , j'ajoute la frq de ce mot dans la 3 éme colonne.
Exemple si je trouve (abc:3) dans f2 . au niveau de la matrice je change : abc 15 3 .
Sinon j'ajoute ce nouveau mot au desous de la matrice par exemple pour (ddc:4), au niveau de la matrice je change : ddc 0 4
et je supprime cette ligne dans f2. Dés que j'atteinds la fin de M , j'ajoute le reste de mon fichier f2 au desous de M.

D'ou la matrice resultat :
abc 15 3
sgh 6 0
g3_ 3 0
ddc 0 4

J'éspère que j'ai bien expliquer le cas.

1) j'essaye pour l'instant e remplir la matrice par les ligne du fichier f1

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 remplissage(BufferedReader f1,BufferedReader f2) throws IOException
{   String[][] matrice = new String [10000][3];
    String c = null;
 
         while ((c = f1.readLine()) != null) {
             //System.out.println(c);
            String[] ligne = c.split(":");
            String gram=ligne[0];
            String fq = ligne[1];
             for(int i = 0; i < 10000; i++){
             for(int j = 0; j <3; j++){
                 matrice[i][0]=gram;
                 matrice[i][1]=fq;
                 matrice[i][2]="0";
            }}
          }
 
 
 
 
          //affichage matrice
         for(int i = 0; i < matrice.length; i++){
            for(int j = 0; j < matrice[i].length; j++){
                System.out.print(matrice[i][j] + " ");
            }
            System.out.println();
        }
 
 
}

Le problème c'est que l'insertion dans la matrice prend en charge sauf la dernière ligne du fichier

[Alkhan]

A ce niveau la Je pense à:
1) Remplir la matrice M par toutes les lignes du fichier f1 (vue qu'il y a pas de redandance des lignes et vu aussi que le f1 a la plus grande taille) {f1: 7702 lignes et f2: 6017}
Normalement ma matrice sera formée par (7702+6017) lignes et 3 colonnes (colonne 1 contient le mot - colonne 2 contient la fq du mot dans f1 - colonne 3 contient la fq du mot dans f2)

un petit exemple :
abc 15 0
sgh 6 0
g3_ 3 0
.... (jusqu'à la fin fichier f1)

2) Parcourir la matrice déja remplie, et ouvrir le ficher f2 en mode écriture. Quand je trouve un mot de matrice existe dans le f2 , j'ajoute ce la frq dans le 3eme colonne Exemple si je trouve (abc:3) dans f2 . au niveau de la matrice je change : abc 15 3 .
Sinon j'ajoute ce nouveau mot au desous de la matrice par exemple pour (ddc:4), au niveau de la matrice je change : ddc 0 4

D'ou la matrice resultat :
abc 15 3
sgh 6 0
g3_ 3 0
ddc 0 4

C'est exactement ce que j'avais compris et que j'ai décris dans mon poste !

En fait je suis un peu hésitée pour le choix de la structure de données matrice , et comme première impression je trouve que celle la plus adaptable pour ensuite comparer deux vecteurs.

Comme je te l'ai indiqué précédemment, ton problème principal avec un tableau c'est que tu ne connais pas sa taille avant d'avoir lu les fichiers car un tableau a deux dimension comme le tiens tu dois pour l'initialiser :

• indiquer le nombre de ligne et dans ton cas tu ne le connais pas et donc tu mets une valeur au hasard
• indiquer le nombre de colonne et dans ton cas c'est 3

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
public static void remplissage(BufferedReader f1,BufferedReader f2) throws IOException
{   String[][] matrice = new String [10000][3]; // Et oui une valeur au hasard !!!
    String c = null;
 
         while ((c = f1.readLine()) != null) {
             //System.out.println(c);
            String[] ligne = c.split(":");
            String gram=ligne[0];
            String fq = ligne[1];
             for(int i = 0; i < 10000; i++){  // la tu va ecraser toute les valeurs avec la dernière ligne lu !
             for(int j = 0; j <3; j++){ // et une boucle qui ne sert a rien car tu écrases 3 fois les mêmes cellule
                 matrice[i][0]=gram;
                 matrice[i][1]=fq;
                 matrice[i][2]="0";
            }}
          }
}

je maintiens donc qu'une Map est plus adaptée pour charger tes fichiers.
Tu commence par créer un objet qui va contenir tes 3 données par exemple :

Code :

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

1
2
3
4
5
6
public class Datas {
  private String gram;
  private int fq1;
  private int fq2;
    .... // les getter et setter
}

et une Map :

Code :

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

Map<String, Datas> matrice = new HashMap<String, Datas>();

et ensuite tu insert tes données :

Code :

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

1
2
3
4
5
6
7
8
9
Datas datas = matrice.get(ligne[0]);
  if (datas != null) {
    datas.setFq1(Integer.parseInt(ligne[1])); // dans le cas du 2eme fichier il faut affecter fq2
  } else {
    Datas newDatas = new Datas();
    newDatas.setGram(ligne[0]);
    newDatas.setFq1(Integer.parseInt(ligne[1]));// dans le cas du 2eme fichier il faut affecter fq2
    matrice.put(ligne[0], newDatas);
  }

en plus cela va fonctionner pour les deux fichiers !

[cheyma]

Bonjour ,

Merci Alkhan ,

j'ai suivie ce que vous m'avez proposé

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 Map<String, Matrice> remplissageDuFichDT(BufferedReader f1) throws IOException {
 
        Map<String, Matrice> mat = new HashMap<String, Matrice>();
        String c = null;
 
        while ((c = f1.readLine()) != null) {
            String[] ligne = c.split(":");
            Matrice m = mat.get(ligne[0]);
            if (m != null) {
                m.setFq1(Integer.parseInt(ligne[1])); // dans le cas du 2eme fichier il faut affecter fq2
            } else {
                Matrice newMatrice = new Matrice();
                newMatrice.setGram(ligne[0]);
                newMatrice.setFq1(Integer.parseInt(ligne[1]));// dans le cas du 2eme fichier il faut affecter fq2
                newMatrice.setFq2(0);
                mat.put(ligne[0], newMatrice);
            }
 
        }
 
        // Afficher le contenu du MAP
        Set listKeys = mat.keySet();  // Obtenir la liste des clés
        Iterator iterateur = listKeys.iterator();
        // Parcourir les clés et afficher les entrées de chaque clé;
        while (iterateur.hasNext()) {
            Object key = iterateur.next();
            System.out.println(key + "\t" + mat.get(key));
        }
     return mat;
    }

Le nombre de fréquence ne s'affiche pas correctement . Merci de m'aider

[cheyma]

Je corrige, en fait ma faute c'est au niveau de l'affichage du 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
public static Map<String, Matrice> remplissageDuFichDT(BufferedReader f1) throws IOException {
 
        Map<String, Matrice> mat = new HashMap<String, Matrice>();
        String c = null;
 
        while ((c = f1.readLine()) != null) {
            String[] ligne = c.split(":");
            Matrice m = mat.get(ligne[0]);
            if (m != null) {
                m.setFq1(Integer.parseInt(ligne[1])); // dans le cas du 2eme fichier il faut affecter fq2
            } else {
                Matrice newMatrice = new Matrice();
                newMatrice.setGram(ligne[0]);
                newMatrice.setFq1(Integer.parseInt(ligne[1]));// dans le cas du 2eme fichier il faut affecter fq2
                newMatrice.setFq2(0);
                mat.put(ligne[0], newMatrice);
                System.out.println(newMatrice.getGram()+"\t"+newMatrice.getFq1()+"\t"+ newMatrice.getFq2());
 
            }
        }
     return mat;
    }

J'essaye d'avancer au niveau du traitement afin de développer toute l'apprcohe de calcul de cosinus
Merci de m'avoir aider

[Alkhan]

bonjour,

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
public static Map<String, Matrice> remplissageDuFichDT(BufferedReader f1) throws IOException {
 
        Map<String, Matrice> mat = new HashMap<String, Matrice>();
        String c = null;
 
        while ((c = f1.readLine()) != null) {
            String[] ligne = c.split(":");
            Matrice m = mat.get(ligne[0]);
            if (m != null) {
                m.setFq1(Integer.parseInt(ligne[1])); // dans le cas du 2eme fichier il faut affecter fq2
            } else {
                Matrice newMatrice = new Matrice();
                newMatrice.setGram(ligne[0]);
                newMatrice.setFq1(Integer.parseInt(ligne[1]));// dans le cas du 2eme fichier il faut affecter fq2
                newMatrice.setFq2(0);
                mat.put(ligne[0], newMatrice);
                System.out.println(newMatrice.getGram()+"\t"+newMatrice.getFq1()+"\t"+ newMatrice.getFq2());
 
            }
        }
     return mat;
    }

Attention car en mettant le System.out a cette endroit, tu n'aura pas toute les valeurs dans le résultat !

Reprenons ton code précédent.....

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
        // Afficher le contenu du MAP
        Set listKeys = mat.keySet();  // Obtenir la liste des clés
        Iterator iterateur = listKeys.iterator();
        // Parcourir les clés et afficher les entrées de chaque clé;
        while (iterateur.hasNext()) {
            Object key = iterateur.next();
            System.out.println(key + "\t" + mat.get(key));
        }
     return mat;
    }

dans ce code tu récupères mal les données de la MAP. En effet, tu peux parcourir directement les valeurs sans les clés ce qui donnerait cela :

Code :

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

1
2
3
4
5
6
Collection<Matrice> listKeys = mat.values(); // Obtenir la liste des Valeurs
Iterator<Matrice> iterateur = listKeys.iterator();
// Afficher les valeurs de l'objet;
while (iterateur.hasNext()) {
	System.out.println(iterateur.next());
}

Et cela te donnera presque la même chose que ce que tu as obtenu !

Mais c'est pas exactement ce que tu veux.
Tu te demande donc pourquoi ce résultat.... la réponse est simple !
Lorsque tu écris cela :

Code :

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

public class Matrice {...

en fait c'est comme si tu écrivais :

Code :

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

public class Matrice extends Object {...

En effet, toute les classes hérite implicitement de la classe Object et lorsque tu passe mat.get(key) ou iterateur.next() à la méthode System.out.println, c'est comme si tu avais écris mat.get(key).toString().
La méthode toString de Object est la suivante :

Code :

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

1
2
3
public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

Ce qui explique l'affichage que tu as obtenu !
Si tu veux changer l'affichage, il faut donc que tu surcharge la méthode toString de la façon suivante :

Code :

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

1
2
3
4
5
6
7
8
public static class Matrice {
....
  @Override
  public String toString() {
      return this.gram + "\t" + this.fq1 + "\t" + this.fq2;
  }
....
}

Et maintenant tu aura l'affichage que tu souhaites.

[cheyma]

Bonjour ,

Merci
Oui, j'ai ajouté la fonction toString() et le problème est
J'ai réctifié et tester le code suivant votre conseils à propos l'affichage de la map , j'ai remplacé ce code (1)

Code :

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

System.out.println(newMatrice.getGram() + "\t" + newMatrice.getFq1() + "\t" + newMatrice.getFq2());

par celui-ci (2)

Code :

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

1
2
3
public String toString() {
      return this.gram + "\t" + this.fq1 + "\t" + this.fq2;
  }

Code :

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

1
2
3
4
5
6
Collection<Matrice> listKeys = mat.values(); // Obtenir la liste des Valeurs
        Iterator<Matrice> iterateur = listKeys.iterator();
        //Afficher les valeurs de l'objet;
        while (iterateur.hasNext()) {
            System.out.println(iterateur.next());
        }

Sauf que j'ai remarqué que le code (1) respecte l'ordre des grames au niveau du fichier (triés par ordre alphanumérique) , par contre le code (2) raméne toutes les lignes mais avec chauvauchement.
Je sais pas si ça me dérange après , car je vais chercher chaque gram de la matrice dans un fichier2 , puisque le fichiers contient plusieurs lignes , je pense à appliquer une recherche rapide ,dichotomique par exemple afin de diminuer le temps d'exécutuion de la recherche , surtout que chaque gram est unique dans son fichier et avec le tri je pense que ça diminue le temps du traitement.
Merci

[Alkhan]

Sauf que j'ai remarqué que le code (1) respecte l'ordre des grames au niveau du fichier (triés par ordre alphanumérique) , par contre le code (2) raméne toutes les lignes mais avec chauvauchement.

Si tu as vraiment besoin qu'ils soient triés alors il te suffit de remplacer la HashMap par une TreeMap et ils seront triés automatiquement en fonction de la clé.

car je vais chercher chaque gram de la matrice dans un fichier2....

Je dirais que c'est l'inverse et c'est fait grâce a cette ligne :

Code :

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

Matrice m = mat.get(ligne[0]);

Lorsque tu parcours le fichier2, imaginons que ligne[0] = "abc", s'il y a déjà un objet Matrice (récupéré dans le fichier1) avec cette clé alors la Map te la retourne sinon tu aura m == null

[cheyma]

Rebonjour,
Merci ,

Entre temps j'ai pensé à implémenter cette méthode. je parcours la matrice , pour chaque ligne , je cherche la valeur du gram dans le fichier f2

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
public static Map<String, Integer> trouveGramFich(String mot) throws FileNotFoundException {
         Map<String, Integer> GramFrq = new HashMap<String, Integer>();
        Scanner sc = new Scanner(new File("chemin fichier2"));
        while (sc.hasNextLine()) {
            String line = sc.nextLine();
            String[] ligne1 = line.split(":");
            String Gm = ligne1[0].toLowerCase();
            int Fq = Integer.parseInt(ligne1[1]);
            if (Gm.equals(mot)) {
                GramFrq.put(Gm, Fq);
            }
            else  GramFrq.put(Gm, 0);
        }
        return GramFrq;
 
    }

Ma question, après avoir remplie la matrice mat

Code :

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

 mat.put(ligne[0], newMatrice);

comment je peux la parcourir ligne par ligne pour tester la valeur de gram avec celle dans le fhcier2 ?
Merci

[Alkhan]

Je pense que tu n'as pas compris ce que j'ai dis...

Tu ne dois pas recréer une nouvelle Map !
Tu dois parcourir le fichier2 et mettre a jours les données dans la Map comme tu le fais avec le fichier1. La différence entre les deux c'est qu'au lieu de faire setFq1 tu fais setfq2 !

Code :

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

1
2
3
4
5
6
7
8
9
Matrice m = mat.get(ligne[0]);
            if (m != null) {
                m.setFq2(Integer.parseInt(ligne[1])); // dans le cas du 2eme fichier il faut affecter fq2
            } else {
                Matrice newMatrice = new Matrice();
                newMatrice.setGram(ligne[0]);
                newMatrice.setFq2(Integer.parseInt(ligne[1]));
                mat.put(ligne[0], newMatrice);
            }

[cheyma]

Oui Oui , vous avez raison , donc pour cet exemple et pour f1 et f2


ça donne comme résultat:



Merci

[cheyma]

Bonsoir ,
Encore je rencontre la même question ,
Comment je peux parcourir la matrice
Pour avoir comparer les valeurs de gram avec d'autres déjà données
J'ai extrait à partir d'un mot saisi au clavier des sous chaînes de 3 caractère (gram) chacunes
Merci

[Alkhan]

Bonsoir ,
Encore je rencontre la même question ,
Comment je peux parcourir la matrice
Pour avoir comparer les valeurs de gram avec d'autres déjà données
J'ai extrait à partir d'un mot saisi au clavier des sous chaînes de 3 caractère (gram) chacunes
Merci

J'ai déjà répondu a tout cela dans les posts précédent, mais je vais en faire un petit résumé !

si tu cherche un "gram" spécifique dans la Map il suffit de faire :

Code :

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

1
2
String gram = "leGramQueTuCherche";
Matrice m = mat.get(gram);

si tu souhaites parcourir l'ensemble du contenu de la Map comme pour l'afficher dans la console :

Code :

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

1
2
3
4
5
6
Collection<Matrice> listVals = mat.values(); // Obtenir la liste des Valeurs
        Iterator<Matrice> iterateur = listVals.iterator();
        //Afficher les valeurs de l'objet;
        while (iterateur.hasNext()) {
            System.out.println(iterateur.next()); // ici la méthode next te retourne un objet de type Matrice
        }

[cheyma]

Bonjour,

Merci , je m'adresse à vous encore une fois pour demander l'aide

Je voudrais préparer 3 vecteurs (1er =Extrait à partir d'un mot saisi au clavier, 2eme et 3éme = remplissage à partir de la matrice ) afin de mesurer le cos entre deux vecteurs. Ci-dessous mon essai :

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
 
  private List<Integer> vectDT = new ArrayList<>();
    private List<Integer> vectNDT = new ArrayList<>();
 
    public void vecteursDT_NDT(Map<String, Matrice> mat, ArrayList<String> list) {   // declarer deux vecteurs
        Matrice m;
        for (String s : list) {
            m = mat.get(s);
 
            vectDT.add(m.getFq1());
            vectNDT.add(m.getFq2());
        }
        System.out.println("*****************************");
        System.out.println("Taile DT = " + vectDT.size());
        System.out.println("Taile NDT = " + vectNDT.size());
        System.out.println("******** DT **************");
 
        for (Integer x : vectDT) {
            System.out.println(x);
        }
        System.out.println("********** NDT *******************");
 
        for (Integer x : vectNDT) {
            System.out.println(x);
        }
           }
 
    private List<Integer> listMot = new ArrayList<>();
 
    public List<Integer> occurence(ArrayList<String> list) {
        Set<String> unique = new HashSet<String>(list);
        for (String key : unique) {
            System.out.println(key + ":" + Collections.frequency(list, key));
            listMot.add(Collections.frequency(list, key));
 
        }
 
        return listMot;
    }

Ce code ne me donne pas la bonne solution parceque au niveau des deux vecteurs, il y a une redendance . Prenons l'exemple du mot "bonbon" l'extraction donne : [_bo, bon, onb, nbo, bon, on_]
d'ou :

Mais au niveau des vecteurs bon:4 (dans la liste1) et bon:265 (dans la liste2) s'affichent deux fois avec redendance :/
et

Puis j'ai essayé d'impléménter le code ci-dessous après avoir changer la structure de donné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
public void vecteursDT_NDT(Map<String, Matrice> mat, ArrayList<String> list) { 
              Matrice m;
        for (String s : list) {
            m = mat.get(s);
            vectDT.put(m.getGram(),m.getFq1());
            vectNDT.put(m.getGram(),m.getFq2());
        }
        System.out.println("*****************************");
        System.out.println("Taile DT = " + vectDT.size());
        System.out.println("Taile NDT = " + vectNDT.size());
        System.out.println("******** DT **************");
        occurence2(vectDT);
 
        System.out.println("********** NDT *******************");
      occurence2(vectNDT);
 
    }

j'ai essayé à travers la fonction occurence2 d'éliminer la redandance des grams (Les 3 caractères consécutif extrait) de la HashMap<String, Integer>

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 private List<Integer> listMotVec = new ArrayList<>();
 
     public List<Integer> occurence2(HashMap<String, Integer> hp) {
        Set<String> unique = new HashSet<String>(hp.keySet());
        for (String key : hp.keySet()) {
            System.out.println(key + "\t" + Collections.frequency(hp.values(), key));
            listMotVec.add(Collections.frequency(hp.values(), key));
 
        }
 
        return listMotVec;
    }

J'ai garder le fonction Occurence. Voila les résultats obtenus :/

liste de fq1:

liste de fq2:



Donc même avec le changement de structure , ça donne pas le bon résultat
Merci de m'aider

[Alkhan]

Bonjour,

Franchement ton explication part dans tout les sens, ce qui donne au final que c'est incompréhensible !
J'ai même pas compris ce que tu essayes de faire.
Tu donnes des résultats mais en disant que c'est pas ce que tu veux, il faudrait nous montrer ce que tu souhaites obtenir !

Un exemple avec les valeurs en entré et ce que tu veux en sortie cela permettra de mieux comprendre

[cheyma]

Bonjour ,

J'ai cru que j'ai bien expliqué . Vous avez raison
Prenons un exemple du mot saisie au clavier : _bonbon_ ---> _bo, bon, onb, nbo, bon, on_
ça nous donne (gram:nombre de fréquence)
bon:2
on_:1
onb:1
nbo:1
_bo:1

2 1 1 1 1 (présente un vecteur de taille 5)
Après avoir exécuté notre 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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
 public static Map<String, Matrice> remplissageDuFichDT(BufferedReader f1, BufferedReader f2) throws IOException {
 
        Map<String, Matrice> mat = new HashMap<String, Matrice>();
        String c1 = null;
        String c2 = null;
        while ((c1 = f1.readLine()) != null) {
            String[] ligne = c1.split(":");
            Matrice m = mat.get(ligne[0]);
            if (m != null) {
                m.setFq1(Integer.parseInt(ligne[1])); // affecter la fréquence Fq1 du fichier DT dans la matrice 
            } else {
                Matrice newMatrice = new Matrice();
                newMatrice.setGram(ligne[0]);
                newMatrice.setFq1(Integer.parseInt(ligne[1]));// affecter la fréquence Fq1 du fichier DT dans la matrice
                newMatrice.setFq2(0);
                mat.put(ligne[0], newMatrice);
            }
        }
 
        while ((c2 = f2.readLine()) != null) {
            String[] ligne = c2.split(":");
            Matrice m = mat.get(ligne[0]);
            if (m != null) {
                m.setFq2(Integer.parseInt(ligne[1])); // // affecter la fréquence Fq2 du fichier NDT dans la matrice
            } else {
                Matrice newMatrice = new Matrice();
                newMatrice.setGram(ligne[0]);
                newMatrice.setFq2(Integer.parseInt(ligne[1]));// affecter la fréquence Fq2 du fichier NDT dans la matrice
                newMatrice.setFq1(0);
                mat.put(ligne[0], newMatrice);
            }
        }
 
        Collection<Matrice> listKeys = mat.values(); // Obtenir la liste des Valeurs
        Iterator<Matrice> iterateur = listKeys.iterator();
        //Afficher les valeurs de l'objet;
        while (iterateur.hasNext()) {
            System.out.println(iterateur.next());
        }
 
        return mat;
    }
 
    /**
     * *********************************************************************
     * Extraire les vecteurs DT , NDT et le mot
     * *****************************************************************
     */
    private List<Integer> vectDT = new ArrayList<>();
    private List<Integer> vectNDT = new ArrayList<>();
 
    public void vecteursDT_NDT(Map<String, Matrice> mat, ArrayList<String> list) {   // declarer deux vecteurs
        //int vectMot[]= new int[list.size()];
        Matrice m;
        for (String s : list) {
            m = mat.get(s);
 
            vectDT.add(m.getFq1());
            vectNDT.add(m.getFq2());
        }
        System.out.println("*****************************");
        System.out.println("Taile DT = " + vectDT.size());
        System.out.println("Taile NDT = " + vectNDT.size());
        System.out.println("******** DT **************");
 
        for (Integer x : vectDT) {
            System.out.println(x);
        }
        System.out.println("********** NDT *******************");
 
        for (Integer x : vectNDT) {
            System.out.println(x);
        }
           }
 
    private List<Integer> listMot = new ArrayList<>();
 
    public List<Integer> occurence(ArrayList<String> list) {
        Set<String> unique = new HashSet<String>(list);
        for (String key : unique) {
            System.out.println(key + ":" + Collections.frequency(list, key));
            listMot.add(Collections.frequency(list, key));
 
        }
 
        return listMot;
    }

Le resultat obtenu

97 4 0 6 4 14 (présente un vecteur de taille 6)
Le resultat souhaité : Liste1
bon:4
on_:14
onb:0
nbo:6
_bo:97
4 14 0 6 97 (présente un vecteur de taille 5)
La même chose pour Liste 2

Résumé:
97 4 0 6 4 14 (présente un vecteur de taille 6)
4 14 0 6 97 (présente un vecteur de taille 5)
Je vais comparer ensuite ces deux vecteurs alors que ma méthode (ne me garantie pas ni le même ordre ni la même talle )


Merci