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

Publié par IB dans tuto

On ne voit pas le gros bouton rouge 'Download' pour charger les 3 scripts, dont vous parlez sur le site

Publié par diet dans CMS

Mais programme-dietetique.com est un site. En logiciel il y a diettesettics.com

Publié par Julie dans logiciel

C'est donc un moteur de recherche specialise. On peut vraiment rechercher tous les domaines que l'on veut. Cela permettrait aux gens de ne plus se faire arnaquer. Quelle bonne idee!

Publié par olibul dans CMS

var
fn: string;

begin

Result:= False;
if strFont <> \'\' then begin

// Tester le nom: si affectation directe à TFont, modifications aléatoires

Publié par Fobec dans java

As-tu essaye sans le parametre de la cle ?
(supprimer la ligne url += "&key=" + this.ApiKey;)
A priori, cela fonctionne sans aucune authentification sur l'api ;)