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 7962 fois
Public
Internaute
Auteur de la publication
Fobec
Admin
Auteur de 267 articles
|BIO_PSEUDO|
Commentaires récents

Publié par Michael dans tuto

Merci pour ce partage, ca m'a ete tres utile pour une application hta que j'ai developper pour mon travail.
Peut etre modifier le script afin de creer des graphiques differentes (en forma...

Publié par pat59 dans CMS

j espere que le jeu vas fonctionner car vous le donnez mais il est bloqué snifff

Publié par Deepan dans php5

Bonjour,
Merci pour ce tuto qui m'a bien aide.
Je donne ici les modifications apportees pour que cela fonctionne chez moi.

/****************************************
* Ouvrir u...

Publié par l'indik dans java

Sauf que si l'objet n'est plus utilisé, quand tu fait ton new , la mémoire sera automatiquement libéré si cela est nécessaire. Donc l'utilisation de System.gc() n'es...

Publié par Roy2014 dans tuto

Bonjour et merci pour ce tuto interessant. Je pense que tout le monde souffre avec 1and1 du fait que l'on puisse pas gziper directement via le htaccess!!
j'aurais une petite question:
tu dis a p...