Discussion :

[chenwaZi]

Salut,

Je suis entrain de parser un fichier XML très large avec le SAX parser de JAVA. Le fichier est structuré comme suit :

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
 
<?xml version="1.0" encoding="utf-8"?>
<LexicalResource>
  <Lexicon label="Arabic" language="arb" languageCoding="UTF-8" owner="http://www.globalwordnet.org/AWN/" version="1.0">
    <LexicalEntry id="$Ary_AlmtwsT_1">
      <Lemma partOfSpeech="n" writtenForm="aaaa bbbbb"/>
      <Sense id="$Ary_AlmtwsT_1_mnTqp_$Ary_AlmtwsT_n1AR" synset="mnTqp_$Ary_AlmtwsT_n1AR"/>
    </LexicalEntry>
    <LexicalEntry id=" kiyoluw mitor_1">
      <Lemma partOfSpeech="n" writtenForm=" ccccc ddddd"/>
      <Sense id=" kiyoluw mitor_1_kiyoluw_mitor_n1AR" synset="kiyoluw_mitor_n1AR"/>
    </LexicalEntry>
    <LexicalEntry id=" ZalomA'_1">
      <Lemma partOfSpeech="n" writtenForm=" fffffff"/>
      <Sense id=" ZalomA'_1_ZalAam_n1AR" synset="ZalAam_n1AR"/>
      <WordForm formType="root" writtenForm="aze"/>
    </LexicalEntry>
  </Lexicon>
</LexicalResource>

Ma question est la suivante : je veut avoir les nombre de tous les `writtenForm` de l'élément `Lemma` qui ont plusqu'une seul mot classé selon leur `partOfSpeech`.

[joel.drigo]

Salut,

Déjà, je te conseille StAX plutôt que SAX, qui sera plus simple à utiliser.

Ensuite, je ne suis pas très sûr de comprendre ce dont tu parles : c'est quoi un mot classé selon son 'partOfSpeech' ? C'est quoi l'attribut pour le mot ? Que signifie classé par son 'partOfSpeech' ? Quand tu parles de "les nombres de ", tu veux dire le "nombre de" (comptage) ou les valeurs se trouvant dans l'attribut writtenForm (soit des codes de caractères à priori).

A priori, je dirais qu'une map, avec un compute pour écrire dedans le compteur devrait le faire, ensuite un stream avec filter pour récupérer ce qui on plus d'un mot classé...

Par exemple, pour récupérer les partOfSpeech de Lemma qui se trouve plus de 5 fois dans le fichier :

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
Map<String, Integer> counter=new HashMap<>();
 
try(InputStream inputStream = Files.newInputStream(Paths.get(nomfichier))) {
    XMLStreamReader xmlReader = XMLInputFactory.newFactory().createXMLStreamReader(inputStream);
    try {
        while ( xmlReader.hasNext() ) {
            switch( xmlReader.next() ) {
            case XMLStreamReader.START_ELEMENT:
                 switch(xmlReader.getLocalName()) {
                     case "Lemma":
                          counter.compute(xmlReader.getAttributeValue(null, "partOfSpeech"),(k, v) -> (v == null) ? 1 : v+1);
                          break;
                     }
                 }
                 break;
     	    }
     	}
     finally {
	xmlReader.close();
     }
  } catch (IOException | XMLStreamException e) {
	e.printStackTrace();
}
 
List<String> list = counter.entrySet().stream().filter(e->e.getValue()>5).map(e->e.getKey()).collect(Collectors.toList());

[chenwaZi]

Le fichier est très gand c'est pour ça que j'ai mentionné SAX parser. L’élément `Lemma` contient 4 types de `partOfSpeech` (n, v, a, r) donc le programme va conter selon le type, par exemple "100 writtenForm de type n / 200 writtenForm de type v / etc..." bien sur le programme va conter que les `writtenForm` qui ont plus que 2 mots. (le writtenForm sont écrits en arabe c'est pour ca qu'il sont mal afficher)

[joel.drigo]

StAX permet de lire en flux les fichiers : il est justement tout indiqué pour lire des XML très grand, mais pas besoin d'implémenter un handler.

Ensuite, je ne comprends toujours pas ce que veux pouvoir dire `writtenForm` qui ont plus que 2 mots : writerForm est un attribut qui contient une valeur. Quelle est la condition en Java qui indique que cette valeur correspond à "plus de 2 mots" ?

Le code que je t'ai donné donne bien dans la map le nombre d'occurences de chaque valeur de partOfSpeech, si on affiche la map counter, on va avoir un truc comme ça :

{ "a'=123, "v"=245, "r"=21, "n"=122 }

[chenwaZi]

Oui, je sais et merci pour le code

Ce que je veux moi c'est de conter les writerForm qui contient une chaine de caractaire ( c-d-a leurs valeurs) comporte plus que 2 mots

[joel.drigo]

Ce que je veux moi c'est de conter les writerForm qui contient une chaine de caractaire ( c-d-a leurs valeurs) comporte plus que 2 mots

Ok, writerForm contient donc une phrase (en arabe donc), et tu ne veux que les phrases qui ont plus de 2 mots... On ne peut pas deviner que writerForm contient une phrase !!!

Pour compter les mots dans une phrase, il faut découper la phrase en mots : on peut faire ça avec split. En français, il suffit de couper par rapport aux espaces et signe de ponctuation, ce qu'on peut faire comme ça :
On précalcule un pattern au début : Pattern pattern = Pattern.compile("(\\p{Punct}|\\s)+")Le nombre de mots est donc : pattern.split(text).length, ou text est le texte.

Donc dans le code que je t'ai indiqué il suffit d'ajouter la condition :

Code :

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

1
2
3
4
5
6
case "Lemma":
   if ( pattern.split(xmlReader.getAttributeValue(null,"writerForm")).length>2 ) {
       counter.compute(xmlReader.getAttributeValue(null, "partOfSpeech"),(k, v) -> (v == null) ? 1 : v+1);
   }
   break;
};

[chenwaZi]

Pour que vous me comprenez bien, les writerForm sont juste des mots certains d'entre eux sont des mots composes d'autres sont juste des mots simple

Le code m'a rien afficher Voulez-vous verifier avec moi.

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
 
public class test {
 
    public static void main(String[] args) {
 
        Map<String, Integer> counter=new HashMap<>();
        Pattern pattern = Pattern.compile("(\\p{Punct}|\\s)+");
        try(InputStream inputStream = Files.newInputStream(Paths.get("lexicalEnt.xml"))) {
            XMLStreamReader xmlReader = XMLInputFactory.newFactory().createXMLStreamReader(inputStream);
            try {
                while ( xmlReader.hasNext() ) {
                        switch( xmlReader.next() ) {
                            case XMLStreamReader.START_ELEMENT:
                                switch(xmlReader.getLocalName()) {
                                    case "Lemma":
                                    if (pattern.split(xmlReader.getAttributeValue(null,"writerForm")).length>2 ) {
                                    counter.compute(xmlReader.getAttributeValue(null, "partOfSpeech"),(k, v) -> (v == null) ? 1 : v+1);
                                    break;
                                    }
                                }
                            }
                        break;
                    }
                }
            finally {
                xmlReader.close();
            }
          } catch (IOException | XMLStreamException e) {
            e.printStackTrace();
        } 
        List<String> list = counter.entrySet().stream().filter(e->e.getValue()>5).map(e->e.getKey()).collect(Collectors.toList());
        System.out.print(list);
 
     }
}

[joel.drigo]

Le code ne peut pas rien afficher, soit ça affiche une erreur (sous forme de stacktrace), soit ça affiche une liste vide au pire (donc "()"). Sinon, si tu testes avec l'exemple donné dans ton message, c'est normal que la liste soit vide : il n'y a aucun writerForm avec plus de 2 mots.

List<String> list = counter.entrySet().stream().filter(e->e.getValue()>5).map(e->e.getKey()).collect(Collectors.toList());ça tu peux l'enlever, c'était pour te donner un exemple, mais ça ne sert à rien dans ton programme. C'est la map counter ton résultat.

J'ai vu que tu avais remplacé les mots dans ton exemple de xml : les mots sont simplement séparés par des espaces ! Si tu l'avais dit clairement dès le début, j'aurais directement donné la bonne regex (c'est juste " "). Cela dit la regexp doit fonctionner aussi même s'il n'y a que des espaces comme séparateurs.

[chenwaZi]

Oui le programme m'a affiché une liste vide {}

J'ai mentionné que les writerForm contient juste des mots que ce soit composé ou simple

J'ai pas compris ce que vous avez dit à propos le regex et la regexp j'ai changé ("(\\p{Punct}|\\s)+") par "#\\s" mais rien n'a changé le prog. tjrs comme {}

Qu'est ce que je dois changer pour que le programme fonctionne correctement?

[joel.drigo]

J'ai mentionné que les writerForm contient juste des mots que ce soit composé ou simple

Ça veut tout dire et rien dire à la fois : un attribut xml contient que des caractères. Si tu y mets des mots, c'est que tu utilises une forme de chaines de caractères tels qu'on puisse y retrouver des mots : il m'est IMPOSSIBLE de deviner quel format tu utilises : si les mots sont séparés par des espaces, des virgules ou je ne sais quoi d'autre ! Tu peux me répeter ton histoire de mots et mots composés dans tous les sens autant de fois que tu veux, ça ne me dira pas quel caractère permet de distinguer un mot d'un autre.

J'ai pas compris ce que vous avez dit à propos le regex et la regexp j'ai changé ("(\\p{Punct}|\\s)+") par "#\\s" mais rien n'a changé le prog. tjrs comme {}

Où est-ce que tu as bien pu lire qu'il fallait remplacer "(\\p{Punct}|\\s)+" par ça "#\\s" ? J'ai supposé que le séparateur était une espace et donc que la regexp pouvait être remplacée par " " (une espace).

Qu'est ce que je dois changer pour que le programme fonctionne correctement?

Dans le code que j'ai mis j'ai mis "writerForm" en nom d'attribut alors que c'est "writtenForm" dans le xml : il faut que tu changes ça déjà pour que ça marche.

[chenwaZi]

J'ai pas encore compris c'est quoi le problème avec les writtenForm ; Lemma est un attribue. writtenForm est un élément de Lemma qui a une valeur, Cette valeur là peut être une mot simple (en arabe) comme lire / écrire / dormir... ou bien un groupe de mots come ali marche / tu est malade .... Je crois que c'est simple

J'ai pas dis qu'il fallait remplacer "(\\p{Punct}|\\s)+" par ça "#\\s", j'ai juste chercher dans le net ce que veut dire compile et ces différentes paramètres.

J'ai remplacé "writerForm" par "writtenForm" mais tjrs le vide {}

[joel.drigo]

J'ai pas encore compris c'est quoi le problème avec les writtenForm ;

C'est que l'attribut s'appelle writtenForm d'après le xml que tu as mis dans ton premier message. Or, quand j'ai écris mon exemple, je me suis basé sur le nom de l'attribut dans ton message d'avant, "writerForm". Si on lit l'attribut "writerForm", on ne risque pas de lire l'attribut "writtenForm"...

Lemma est un attribue.

Non, un élément.

writtenForm est un élément de Lemma qui a une valeur,

Non, un attribut de Lemma.

Cette valeur là peut être une mot simple (en arabe) comme lire / écrire / dormir... ou bien un groupe de mots come ali marche / tu est malade .... Je crois que c'est simple

Le problème n'est pas que ça soit simple ou pas, le problème c'est que je ne peux pas le deviner : toi tu le sais, moi je ne le connais ton format. Et ça me semble évident de le comprendre.

J'ai pas dis qu'il fallait remplacer "(\\p{Punct}|\\s)+" par ça "#\\s", j'ai juste chercher dans le net ce que veut dire compile et ces différentes paramètres.

Non ça veut dire un # suivi d'un whitespace.

J'ai remplacé "writerForm" par "writtenForm" mais tjrs le vide {}

Quand tu as recopié mon exemple, tu as déplacé les break des switch dans le while et le if...
Le bon code c'est :

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
Map<String, Integer> counter=new HashMap<>();
	        Pattern pattern = Pattern.compile(" ");
	        try(InputStream inputStream = Files.newInputStream(Paths.get("lexicalEnt.xml"))) {
	            XMLStreamReader xmlReader = XMLInputFactory.newFactory().createXMLStreamReader(inputStream);
	            try {
	                while ( xmlReader.hasNext() ) {
	                        switch( xmlReader.next() ) {
	                            case XMLStreamReader.START_ELEMENT:
	                                switch(xmlReader.getLocalName()) {
	                                    case "Lemma":
	                                    if (pattern.split(xmlReader.getAttributeValue(null,"writtenForm")).length>2 ) {
	                                    	counter.compute(xmlReader.getAttributeValue(null, "partOfSpeech"),(k, v) -> (v == null) ? 1 : v+1);
	                                    }
	                                    break;
	                                }
	    	                        break;
	                            }
	                    }
	                }
	            finally {
	                xmlReader.close();
	            }
	          } catch (IOException | XMLStreamException e) {
	            e.printStackTrace();
	        } 
	        System.out.println(counter);

[chenwaZi]

J'ai pas compris ce que vous avez dit mais je viens de tester et ça fonctionne comme un charme hahaha

Merci beaucoup mon ami et je me demande si jamais je rencontrerai un autre problème avec XML et JAVA je peut t’adresser ?

[tsuji]

Pour le faire en sax, on peut construire un simple handler sous-classé la classe d'utilité DefautHandler. Il est simple parce que les info sur des attributs ne s'attachent qu'au évenement startElement. Un peu comme ça.

Code java :

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
public class CountHandler extends org.xml.sax.helpers.DefaultHandler {
    //private static final Logger logger=LogManager.getLogger(CountHandler.class);
    private Integer min_mots;
    private Map<String, Integer> map;
 
    CountHandler () {
        this.min_mots=new Integer(1);
        map=new HashMap<String, Integer>();
    }
 
    CountHandler(Integer min_mots) {
        this.min_mots=min_mots;
        map=new HashMap<String, Integer>();
    }
 
    @Override
    public void startElement(String namespaceURI, String localName, String qName, Attributes atts) {
 
        String partOfSpeech="";
        boolean bAdmittedForm=false;
 
        if (localName.equals("Lemma")) {
            for (int i = 0; i < atts.getLength(); i++) {
                if (atts.getLocalName(i).equals("partOfSpeech")) {
                    partOfSpeech=atts.getValue(i);
                } else if (atts.getLocalName(i).equals("writtenForm")) {
 
                    //on peut l'élaborer comme fait dans les autres excellentes réponses, c'est sous-entendu.
                    int count=atts.getValue(i).trim().split("\\s+").length;
 
                    if (count>=min_mots.intValue()) {
                        bAdmittedForm=true;
                    }
                }
            }
 
            if (!partOfSpeech.equals("") && bAdmittedForm) {
                int j=(map.get(partOfSpeech)!=null)?map.get(partOfSpeech).intValue()+1:1;
                map.put(partOfSpeech, new Integer(j));
            }
 
            /* testing
            for (Map.Entry entry : map.entrySet()) {
                logger.info(entry.getKey() + ", " + entry.getValue());
            }
            */
 
        }
    }
 
    public Map<String, Integer> getMap() {
        return this.map;
    }
}

On fait une instance de CountHandler et la passe au "reader" (XMLReader de parseur de sax) avec la MIN_MOTS comme pour l'instance 2. Au final, on retire le map par la méthode getMap() pour faire ce qu'on veut.

Code java :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
    spf=SAXParserFactory.newInstance();
    //configuer des paramètres
    parser=spf.newSAXParser();
    reader=parser.getXMLReader();
    CountHandler countHandler=new CountHandler(MIN_MOTS);    //comme new Integer(2)
    reader.setContentHandler(countHandler);
    //etc charger le fichier
    //et au final
    Map<String, Integer> map=countHandler.getMap();
    /* faire ce qu'on veut 
    for (Map.Entry entry : map.entrySet()) {
        logger.info(entry.getKey() + ", " + entry.getValue());
    }
    */

Voilà une possible réalization en sax.