Publié le 20/06/2011
Auteur fobec
Réseaux sociaux
0 partages
0 tweets
0 plus
1 commentaires

Calculer la frequence des caracteres d'un texte

L' analyse fréquentielle des lettres consiste à examiner le contenu d'un texte. Souvent utilisé en cryptographie ou pour déterminer la langue d'un texte, voyons comment effectuer ces calculs avec JAVA. L'analyse porte aussi bien sur la structure (taille, nombre de ligne) que sur le contenu (nombre de mot, fréquence de lettre).

Analyser le contenu d'un texte

A partir d'un fichier texte ou d'un string, la class extrait les données suivantes:
- charsize(): longueur du texte (en caractère),
- linecount(): nombre de ligne,
- wordcount(): nombre de mot,
- letterFrequency(): analyse fréquentielle.
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.StringTokenizer;
import java.util.logging.Level;
import java.util.logging.Logger;
 
/**
 * Calculer la frequence des caractères d'un texte en français
 * @author fobec.com 2011
 */
public class TextAnalyser {
 
    /**
     * Texte à analyser
     */
    private String mytext = "";
    /**
     * nombre de ligne dans le texte
     */
    private int linecount = 0;
 
    /**
     * Fixer le texte à partir d'un string
     * @param text
     */
    public void assign(String text) {
        this.mytext = text;
        StringTokenizer st = new StringTokenizer(this.mytext, System.getProperty("line.separator"));
        this.linecount = st.countTokens();
    }
 
    /**
     * Charger le texte à partir d'un fichier
     * @param filename nom du fichier
     */
    public void loadfile(String filename) {
        FileReader filereader = null;
        StringBuffer contents = new StringBuffer();
        try {
            filereader = new FileReader(filename);
            BufferedReader bufferReader = new BufferedReader(filereader);
            String line = null;
            while ((line = bufferReader.readLine()) != null) {
                contents.append(line).append(System.getProperty("line.separator"));
                this.linecount  ;
            }
        } catch (FileNotFoundException ex) {
            Logger.getLogger(TextAnalyser.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IOException ex) {
            Logger.getLogger(TextAnalyser.class.getName()).log(Level.SEVERE, null, ex);
        }
        this.mytext = contents.toString();
    }
 
    /**
     * Nombre de caractère
     * @return
     */
    public int charsize() {
        return this.mytext.length();
    }
 
    /**
     * Nombre de ligne
     * @return
     */
    public int linecount() {
        return this.linecount;
    }
 
    /**
     * Nombre de mot
     * @return
     */
    public int wordcount() {
        StringTokenizer st = new StringTokenizer(this.mytext);
        return st.countTokens();
    }
 
    /**
     * Frequence de caractère
     * @return
     */
    public int[] letterFrequency() {
        int[] freqs = new int[26];
        String text = this.mytext.toLowerCase();
 
        char[] chars = text.toCharArray();
        int p = 0;
        int len = text.length();
        for (int i = 0; i < len; i  ) {
            p = chars[i] - 97;
            if (p > -1 && p < 27) {
                freqs[p]  ;
            }
        }
        return freqs;
    }
 
    /**
     * Exemple
     * @param args
     */
    public static void main(String[] args) {
        TextAnalyser textAnalyser = new TextAnalyser();
        textAnalyser.loadfile("c://123.txt");
        System.out.println("Analyse du texte");
        System.out.println("---------------------------------------------------");
        System.out.println("Taille: "   textAnalyser.charsize()   " caracteres");
        System.out.println("Longueur: "   textAnalyser.linecount()   " lignes");
        System.out.println("Contenu: "   textAnalyser.wordcount()   " mots");
        System.out.println();
        System.out.println("Frequence des caracteres");
        System.out.println("---------------------------------------------------");
        int[] freq = textAnalyser.letterFrequency();
        int charsum=0;
        /**
         * Nombre de caractère conmpris entre [a..z]
         */
        for (int i = 0; i < 26; i  ) {
            charsum =freq[i];
        }
        int c;
        float f=0;
        /**
         * Analyse frequentielle des caractères
         */
        for (int i = 0; i < 26; i  ) {
            c=i 97;
            f=freq[i]*100;
            System.out.println((char)c " -> " freq[i] " fois - " f/charsum " %");
        }
    }
}

Exemple d'analyse de texte

Analyse du texte
---------------------------------------------------
Taille: 8302 caractères
Longueur: 301 lignes
Contenu: 1204 mots

Fréquence des caractères
---------------------------------------------------
a -> 417 fois soit 7.954979 %
b -> 46 fois soit 0.87752765 %
c -> 194 fois soit 3.7008774 %
d -> 201 fois soit 3.8344142 %
e -> 738 fois soit 14.078596 %
f -> 73 fois soit 1.3925983 %
g -> 66 fois soit 1.2590615 %
h -> 63 fois soit 1.2018313 %
i -> 442 fois soit 8.431896 %
j -> 76 fois soit 1.4498283 %
k -> 20 fois soit 0.38153377 %
l -> 213 fois soit 4.0633345 %
m -> 171 fois soit 3.2621138 %
n -> 377 fois soit 7.1919117 %
o -> 259 fois soit 4.940862 %
p -> 147 fois soit 2.8042731 %
q -> 54 fois soit 1.0301411 %
r -> 361 fois soit 6.8866844 %
s -> 434 fois soit 8.279283 %
t -> 372 fois soit 7.096528 %
u -> 383 fois soit 7.3063717 %
v -> 41 fois soit 0.78214425 %
w -> 49 fois soit 0.9347577 %
x -> 13 fois soit 0.24799694 %
y -> 28 fois soit 0.53414726 %
z -> 4 fois soit 0.07630675 %

Remarque sur la fréquence des caractères

En fait, le fichier 123.txt contient le texte d'une page web pris au hasard pour tester la class. L'analyse fréquentielle nous apprend que les 5 caractères les plus utilisés dans ce texte sont E, A, S, I, U alors que les lettres les plus utilisées en français sont E, A, I, S, T. Les valeurs sont proches et effectivement, le fichier 123.txt contient une discussions d'un forum français.
Ce genre d'analyse peut être poussé plus loin en calculant la longueur moyenne des mots (charsum/1204) ou encore en estimant la proportion du style (charsum/8302).

Ajouter un commentaire

Les champs marqués d'un * sont obligatoires, les adresses emails se sont pas publiées.
avatar mohammed

Publié par mohammed

le 28/07/2012 à 16:49:30

Bonjour ,Merci pour ce travail ,juste j'ai une question pour ce qui concerne les textes avec les caracteres speciaux comment faire??

A lire aussi

Réseaux sociaux
Présentation de l'article
Catégorie
java - sources
Mise a jour
20/06/2011
Visualisation
vu 5678 fois
Public
Internaute
Auteur de la publication
Fobec
Admin
Auteur de 261 articles
|BIO_PSEUDO|
Commentaires récents

Publié par Fobec dans CMS

Le code source de l'exemple se trouve dans la pièce jointe (Fiche de l'article -> Boutton Telecharger)

Publié par Fobec dans tuto

Bonjour,

Sur Fobec.com, nous utilisons mod_expires.c pour envoyer automatiquement un code 304 au navigateur internet.
<IfModule mod_expires.c>
ExpiresActive On
ExpiresByType im...

Publié par bapsmaitihere dans logiciel

je souhaite tester

Publié par Franzi dans java

Bonjour,
Le code est simple et compile, après être entré dans public void connect, il n'effectue pas this.session.get.transport et s'arrête. Sous eclipse avec Tomcat, j'ob...

Publié par Fobec dans php5

Bonjour,
vous pouvez poster un message sur le forum, la communaut vous donnera un coup de main pour la mise en place du script.