Problème de parsing

Version imprimable

Problème de parsing

bonjour,

je souhaite parser un fichier xml,

voici mon code

Code:

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
55
56
57
58
 
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import org.jdom2.JDOMException;
import org.jdom2.input.SAXBuilder;
import org.jdom2.Document;
import org.jdom2.Element;
 
 
public class ChargerNotesEtudiants {
 
	 ArrayList<ArrayList<String>> liste = new ArrayList<ArrayList<String>>();
 
    public ChargerNotesEtudiants (String nomfichier) {
 
      SAXBuilder builder = new SAXBuilder();
      File xmlFile = new File(nomfichier);
 
      try {
 
        Document document = (Document) builder.build(xmlFile);
        Element rootNode = document.getRootElement();
        List list = rootNode.getChildren();
 
        ArrayList<String> l=  new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
 
           Element node = (Element) list.get(i);
 
           System.out.println("nom: " + node.getChildText("nom"));
           System.out.println("prenom : " + node.getChildText("prenom"));
           System.out.println("emd2 : " + node.getChildText("emd2"));
           System.out.println("moyenne : " + node.getChildText("moyenne"));
          l.add(node.getChildText("nom"));
          l.add(node.getChildText("prenom"));
          l.add(node.getChildText("emd2"));
          l.add(node.getChildText("moyenne"));
          liste.add(l);
 
        }
 
      } catch (IOException io) {
        System.out.println(io.getMessage());
      } catch (JDOMException jdomex) {
        System.out.println(jdomex.getMessage());
      }
    }
 
	public ArrayList<ArrayList<String>> getListe() {
		return liste;
	}
 
	public void setListe(ArrayList<ArrayList<String>> liste) {
		this.liste = liste;
	}
}

et voici mon fichier xml :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
<?xml version="1.0" encoding="UTF-8"?>
<html>
	<etudiant1>		
		<nom>bibi</nom>
		<prenom>bobo</prenom>
		<notes>
			<emd1>12</emd1>
			<emd2>13</emd2>
			<moyenne>12.5</moyenne>
		</notes>
	</etudiant1>
 
	<etudiant2>		
		<nom>titi</nom>
		<prenom>toto</prenom>
		<notes>
			<emd1>10</emd1>
			<emd2>11</emd2>
			<moyenne>10.5</moyenne>
		</notes>
	</etudiant2>
</html>

et je veux récupérer la liste de liste et voici mon retour :

Code:

1
2
3
 
 
list[[bibi, bobo, null, null, titi, toto, null, null], [bibi, bobo, null, null, titi, toto, null, null]]

et je eux que ça me retourne

Code:

1
2
3
 
 
list[[bibi, bobo, null, null], [ titi, toto, null, null]]

merci pour votre aide

Bonjour,

première remarque ton xml me semble assez mal écrit, il devrait plutôt ressembler à ça :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<?xml version="1.0" encoding="UTF-8"?>
<etudiants>
	<etudiant>		
		<nom>bibi</nom>
		<prenom>bobo</prenom>
                <moyenne>12.5</moyenne>
		<notes>
			<note>12</note>
			<note>13</note>
		</notes>
	</etudiant>
	<etudiant>		
		<nom>titi</nom>
		<prenom>toto</prenom>
                <moyenne>10.5</moyenne>
		<notes>
			<note>10</note>
			<note>11</note>
		</notes>
	</etudiant>
</etudiants>

Je créerai ensuite une classe Etudiant représentant la structure de ton XML :

Code:

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
55
56
57
58
    public class Etudiant
    {
        private String nom;
 
        private String prenom;
 
        private Double moyenne;
 
        private List<Double> notes = new ArrayList<Double>();
 
        public String getNom()
        {
            return nom;
        }
 
        public void setNom(String nom)
        {
            this.nom = nom;
        }
 
        public String getPrenom()
        {
            return prenom;
        }
 
        public void setPrenom(String prenom)
        {
            this.prenom = prenom;
        }
 
 
        public Double getMoyenne()
        {
            return moyenne;
        }
 
        public void setMoyenne(Double moyenne)
        {
            this.moyenne = moyenne;
        }
 
        public void ajouterNote(Double note)
        {
            notes.add(note);
        }
 
 
        public List<Double> getNotes()
        {
            return notes;
        }
 
 
        public void setNotes(List<Double> notes)
        {
            this.notes = notes;
        }
    }

Ce qui te permet ensuite de parser ton fichier XML en une liste d'étudiant :

Code:

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
public class ChargerNotesEtudiants {
 
        List<Etudiant> listeEtudiants = new ArrayList<Etudiant>();
 
       public ChargerNotesEtudiants (String nomfichier) {
         SAXBuilder builderXml = new SAXBuilder();
         File xmlFile = new File(nomfichier);
 
         try {
           Document documentXml = (Document) builderXml.build(xmlFile);
           Element rootNode = documentXml.getRootElement();
           List<Element> noeudEtudiants = rootNode.getChildren();
 
 
           for (Element noeudEtudiant : noeudEtudiants) {
 
               Etudiant etudiant = new Etudiant();
               etudiant.setNom(node.getChildText("nom"));
               etudiant.setPrenom(node.getChildText("prenom"));
               etudiant.setMoyenne(Double.parseDouble(node.getChildText("moyenne")));
 
               List<Element> noeudNotes = noeudEtudiant.getChildren();
               for(Element noeudNote : noeudNotes){
                   etudiant.ajouterNote(Double.parseDouble(noeudNote.getChildText("note")));
               }
 
               listeEtudiants.add(etudiant);
           }
 
         } catch (IOException io) {
           System.out.println(io.getMessage());
         } catch (JDOMException jdomex) {
           System.out.println(jdomex.getMessage());
         }
       }
 
       public List<Etudiant> getListe() {
           return listeEtudiants;
       }
 
       public void setListe(List<Etudiant> listeEtudiants) {
           this.listeEtudiants = listeEtudiants;
       }
   }

Je n'ai pas testé donc ça ne marche peut-être pas (notamment sur le parsing des notes en Double), mais tu vois l'idée je pense. Une List<Etudiant> sera bien plus exploitable pour la suite de ton programme qu'un ArrayList<ArrayList<String>> ...

Une dernière remarque la moyenne ne devrait pas être stockée dans le XML à mes yeux car elle est calculable à partir de l'ensemble des notes. Ton information est donc dupliquée. Mais pour des raisons de performances et de simplicités tu peux la laisser dedans si tu veux. Attention par contre à bien la mettre à jour quand tu rajoutes une note...

Romain.

23/05/2013, 02h38
thelvin

Je suis d'accord, l'erreur n'aurait pas été faite avec une List<Etudiant>, claire et droit au but, à la place d'une ArrayList<ArrayList<String>> où on s'emmêle.

Mais bon, juste pour info : il faut construire new ArrayList<String> à chaque boucle, bien sûr. Pas en dehors de la boucle -_-°.