Structure de données en Java : problème
Bonjour,
J'ai un fichier texte que je dois parser pour récupérer les éléments m'intéressant.
Le fichier se présente de cette façon :
001 PH 000
On ne peut que s'interroger sur les ressorts d'une attitude aussi affligeante.
---
002 pp 001 0000-077 : On ne peut que s'interroger sur les ressorts d'une attitude aussi affligeante
003 fs 002 0000-002 : On
004 fv 002 0003-011 : ne peut que
005 fc 002 0015-062 : s'interroger sur les ressorts d'une attitude aussi affligeante
006 gp 003 0000-002 : On
007 gv 004 0003-011 : ne peut que
008 wd 006 0000-002 : qp <on>
009 wd 007 0003-002 : qp <ne>
010 wd 007 0006-004*: vc <pouvoir>
011 wd 007 0011-003 : <que>
012 gv 005 0015-012 : s'interroger
013 wd 012 0015-002 : qp <se>*
014 wd 012 0017-010*: vi <interroger>
015 gn 005 0028-016 : sur les ressorts
016 wd 015 0028-003 : p <sur>
017 wd 015 0032-003 : o <les>
018 wd 015 0036-008*: n <ressort>
019 gn 005 0045-014 : d'une attitude
020 wd 019 0045-002 : p <de>*
021 wd 019 0047-003 : o <une>
022 wd 019 0051-008*: n <attitude>
023 ga 005 0060-017 : aussi affligeante
024 wd 023 0060-005 : b <aussi>
025 wd 023 0066-011*: a <affligeant>
026 wp 023 0077-001 : .
027 ls 010 0101>008 (0000)
028 ld 014 0101>013 (0000)
001 PH 000
Lionel Jospin rem'89che son ressentiment et se venge.
---
002 pp 001 0000-038 : Lionel Jospin rem'89che son ressentiment
003 fs 002 0000-013 : Lionel Jospin
004 gn 003 0000-013 : Lionel Jospin
005 wd 004 0000-006*: P <Lionel>
006 wd 004 0007-006 : P <Jospin>
007 fv 002 0014-007 : rem'89che
008 fc 002 0022-016 : son ressentiment
009 gv 007 0014-007 : rem'89che
010 wd 009 0014-007*: vc <rem'89cher>
011 gn 008 0022-016 : son ressentiment
012 wd 011 0022-003 : o <son>
013 wd 011 0026-012*: n <ressentiment>
014 pp 001 0039-011 : et se venge
015 gc 014 0039-002 : et
016 wd 015 0039-002*: sc <et>
017 fv 014 0042-008 : se venge
018 gv 017 0042-008 : se venge
019 wd 018 0042-002 : qp <se>
020 wd 018 0045-005*: vc <venger>
021 wp 018 0050-001 : .
022 ls 010 0100>004 (0000)
023 ls 020 0102>010 (0000)
024 ld 020 0101>019 (0000)
Description du fichier :
Ici nous avons une analyse de 2 phrases. Pour chaque phrase nous avons des éléments la décrivant (numéro de ligne et lettre), nous avons aussi des liens syntaxiques à la fin ( lettre "l" suivi d"une autre lettre et des lignes de renvoi.
Pour être plus clair, à partir d'une phrase je voudrai avoir un résultat de cette forme :
Phrase analysée : On ne peut que s'interroger sur les ressorts d'une attitude aussi affligeante.
lien 0: 027 ls 010 0101>008 (0000)
1er renvoi : 010 wd 007 0006-004*: vc <pouvoir>
2eme renvoi : 008 wd 006 0000-002 : qp <on>
lien 1: 028 ld 014 0101>013 (0000)
1er renvoi : 014 wd 012 0017-010*: vi <interroger>
2eme renvoi : 013 wd 012 0015-002 : qp <se>*
Ici je récupère ma phrase, mes liens et mes renvois.
Le problème est que le code que j'ai réalisé ne fonctionne que sur une phrase lorsque j'ai plusieurs phrases dans mon fichier entrée je ne récupère pas les bonnes informations.
Voici mon code :
package mypackage;
- Code: Tout sélectionner
//cette classe permet de lire un fichier texte et de classer les elements de chaque ligne dans un ArrayList
import java.io.*;
import java.util.ArrayList;
import java.util.StringTokenizer;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class TableFiller {
private String[][] datasTable;
int width, height;
/** Creates new TableFiller */
public TableFiller() {
}
public String[][] fill(String dataFile) {
width = 0;
height = 0;
StringBuffer datasBuffer = new StringBuffer();
try {
BufferedReader reader = new BufferedReader(new FileReader(dataFile));
String datasLine = "";
while ((datasLine = reader.readLine()) != null) {
// tokenizer
width = (new StringTokenizer(datasLine, ";")).countTokens();
datasBuffer.append(datasLine + ";");
height++;
}
} catch (FileNotFoundException fnfe) {
System.out.println("Data file not found!");
fnfe.printStackTrace();
} catch (IOException ioe) {
System.out.println("IOException!");
ioe.printStackTrace();
}
return tokenize(datasBuffer.toString());
}
private String[][] tokenize(String datas) {
datasTable = new String[height][width];
StringTokenizer tokenizer = new StringTokenizer(datas, ";");
for (int i = 0; i < height; i++) {
for (int j = 0; j < width; j++) {
String data = tokenizer.nextToken();
datasTable[i][j] = data;
}
}
return datasTable;
}
public int getWidth() {
return width;
}
public int getHeight() {
return height;
}
// /detection de la phrase analyse
public static boolean phrase(String line) {
Pattern pattern1 = Pattern.compile("(^[A-Z][a-z].+)");
Matcher matcher = pattern1.matcher(line);
// if (matcher.find()){
// System.out.println("Phrase analyse : " + matcher.group(1) );
// }
return matcher.find();
}
// /on matche les liens syntaxique SUJET VERBE
public static boolean isliensyntaxiqueSUJ(String line) {
// System.out.println("test"+myTable[index][0]);
// dans cette expression rég on recupere les liens sujet
Pattern pattern = Pattern
.compile("ls ([0-9]{3}) ([0-9]{4})>([0-9]{3})");
// le matcher donne le texte
Matcher matcher = pattern.matcher(line);
// if (matcher.find()){
// System.out.println("La ligne " + matcher.group(1) + " est le sujet du
// verbe de la ligne " + matcher.group(3) + "." );
// }
return matcher.find();
}
// /on matche les liens syntaxique VERBE COD
public static boolean isliensyntaxiqueCOD(String line) {
// dans cette expression reg on recupere les liens cod
Pattern pattern = Pattern
.compile("ld ([0-9]{3}) ([0-9]{4})>([0-9]{3})");
// le matcher donne le texte
Matcher matcher = pattern.matcher(line);
// ** if (matcher.find()){
// System.out.println("La ligne " + matcher.group(1) + " est le COD du
// verbe de la ligne " + matcher.group(3) + "." );
// }
return matcher.find();
}
public static boolean iselementphrase(String line) {
// MATCHER element phrase ddd a-z sauf l+[a-z]
return line.matches("^[0-9]{3} [a-z].+");
}
public static void main(String args[]) {
String phrase = null;
//ArrayList elementphrase = new ArrayList(200);
// on stocke les element phrase et lien syntaxique et phrase et on les indexe
// on lit le fichier et on remplit les tableau
String [] elementphrase = new String[200];
ArrayList liensyntaxique = new ArrayList(200);
TableFiller filler = new TableFiller();
String dataFile = "C:/corpus/perltest.txt";
String[][] myTable = filler.fill(dataFile);
System.out.println("Tableau de donnees: " + myTable.toString());
// Affichage du tableau
for (int i = 0; i < filler.getHeight(); i++) {
// impression des numeros de ligne
if (TableFiller.phrase(myTable[i][0])) {
phrase = myTable[i][0];
//System.out.println(phrase);
}
///on remplit les tab
if (TableFiller.iselementphrase(myTable[i][0])) {
//System.out.println(i);
//System.out.println(myTable[i][0]);
//elementphrase.add(i-1, myTable[i][0]);
elementphrase[i-1] = myTable[i][0];
}
if (TableFiller.isliensyntaxiqueSUJ(myTable[i][0])) {
liensyntaxique.add(myTable[i][0]);
}
if (TableFiller.isliensyntaxiqueCOD(myTable[i][0])) {
liensyntaxique.add(myTable[i][0]);
}
// /ICI ON imprime les elemtn composant le tableau
/*
* for(int j=0 ; j<filler.getWidth() ; j++) {
*
* System.out.println(myTable[i][j]);
* }
*/
//on recupere le lien dans le tableau liensyntaxique
}
System.out.println(phrase);
///une fois le tableau rempli on reparcour les tableau de ls pour rechercher le modele
for (int j = 0; j < liensyntaxique.size(); j++) {
String lien = (String) liensyntaxique.get(j);
System.out.println("lien " + j + ": " + lien );
Pattern pattern = Pattern.compile("l[a-z] ([0-9]{3}) ([0-9]{4})>([0-9]{3})");
//le matcher donne le texte
Matcher matcher = pattern.matcher(lien);
if(matcher.find()){
//System.out.println(matcher.group(1));
//variable de renvoi de l'element 1 du match
int renvoi1 = Integer.parseInt(matcher.group(1));
//variable de renvoi de l'element 2 du match
int renvoi2 = Integer.parseInt(matcher.group(3));
//System.out.println(renvoi1);
//elementphrase.get(renvoi1);
//System.out.println("1er renvoi : " + elementphrase.get(renvoi1));
System.out.println("1er renvoi : " + elementphrase[renvoi1]);
System.out.println("2eme renvoi : " + elementphrase[renvoi2]);
}
}
}
}
Je débute en Java et j'ai réalisé ce code maladroitement.
Le but est de lire le fichier texte et parser mon fichier de la bonne manière pour récupérer les informations de chaque phrase analysée.
Merci de m'indiquer la marche à suivre.
