Bonjour,
je suis en train de créer un parser XML, j'ai utilisé le code ci-dessous qui ne fonctionne pas , en fait la méthode "matches" ne répond pas, bien que le code est correct (copié de ce site même) , voici mon code:
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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
 
import java.io.*;
import org.jdom2.*;
import org.jdom2.input.*;
import org.jdom2.output.*;
import org.jdom2.filter.*;
 
import java.util.List;
import java.util.Iterator;
 
public class JDOM2
{
	static org.jdom2.Document document;
	static Element racine;
 
	   public static void main(String[] args)
	   {
	      //On crée une instance de SAXBuilder
	      SAXBuilder sxb = new SAXBuilder();
	      try
	      {
	         //On crée un nouveau document JDOM avec en argument le fichier XML
	         //Le parsing est terminé ;)
	         document = sxb.build(new File("Exercice2.xml"));
	      }
	      catch(Exception e){}
 
	      //On initialise un nouvel élément racine avec l'élément racine du document.
	      racine = document.getRootElement();
 
	      //Méthode définie dans la partie 3.2. de cet article
	      System.out.println("avant appel d'afficher filtre");
	      afficheFiltre();
	   }
   static void affiche()
   {
      try
      {
         //On utilise ici un affichage classique avec getPrettyFormat()
         XMLOutputter sortie = new XMLOutputter(Format.getPrettyFormat());
         sortie.output(document, System.out);
      }
      catch (java.io.IOException e){}
   }
 
   static void enregistre(String fichier)
   {
      try
      {
         //On utilise ici un affichage classique avec getPrettyFormat()
         XMLOutputter sortie = new XMLOutputter(Format.getPrettyFormat());
         //Remarquez qu'il suffit simplement de créer une instance de FileOutputStream
         //avec en argument le nom du fichier pour effectuer la sérialisation.
         sortie.output(document, new FileOutputStream(fichier));
      }
      catch (java.io.IOException e){}
   }
 
   static void afficheALL()
   {
      //On crée une List contenant tous les noeuds "etudiant" de l'Element racine
      List listEtudiants =  racine.getChildren("etudiant");
 
      //On crée un Iterator sur notre liste
      Iterator i = listEtudiants.iterator();
      while(i.hasNext())
      {
         //On recrée l'Element courant à chaque tour de boucle afin de
         //pouvoir utiliser les méthodes propres aux Element comme :
         //sélectionner un nœud fils, modifier du texte, etc...
         Element courant = (Element)i.next();
         //On affiche le nom de l’élément courant
         System.out.println(courant.getChild("nom").getText());
      }
   }
   static void afficheFiltre()
   {
      //On crée un nouveau filtre
	  // System.out.println("avant instanciation de Filter");
      Filter filtre = new Filter()
      {
         //On défini les propriétés du filtre à l'aide
         //de la méthode matches
 
 
         /**
                 * 
                 */
		private static final long serialVersionUID = 1L;
 
		public boolean matches(Object ob)
         {
            //1 ère vérification : on vérifie que les objets
            //qui seront filtrés sont bien des Elements
 
            if(!(ob instanceof Element)){   return false;}
 
            //On crée alors un Element sur lequel on va faire les
            //vérifications suivantes.
            Element element = (Element)ob;
 
            //On crée deux variables qui vont nous permettre de vérifier
            //les conditions de nom et de prenom
            int verifNom = 0;
            int verifPrenom = 0;
 
            //2 ème vérification: on vérifie que le nom est bien "CynO"
            if(element.getChild("nom").getTextTrim().equals("CynO"))
            {
            	System.out.println("getchild cyno est vérifié");
               verifNom = 1;
            }
            //3 ème vérification: on vérifie que CynO possède un prenom "Laurent"
            //On commence par vérifier que la personne possède un prenom,
            //en effet notre fichier XML possède des étudiants sans prénom !
            Element prenoms = element.getChild("prenoms");
            if(prenoms == null){return false;}
 
            //On constitue une list avec tous les prenom
            List listprenom = prenoms.getChildren("prenom");
 
            //On effectue la vérification en parcourant notre liste de prenom
            //(voir: 3.1. Parcourir une arborescence)
            Iterator i = listprenom.iterator();
            while(i.hasNext())
            {
               Element courant = (Element)i.next();
               if(courant.getText().equals("Laurent"))
               {
                  verifPrenom = 1;
               }
            }
 
            //Si nos conditions sont remplies on retourne true, false sinon
            if(verifNom == 1 && verifPrenom == 1)
            {
               return true;
            }
            return false;
         }
 
		@Override
		public Filter and(Filter arg0) {
			// TODO Auto-generated method stub
			return null;
		}
 
		@Override
		public List filter(List arg0) {
			// TODO Auto-generated method stub
 
			return null;
		}
 
		@Override
		public Object filter(Object arg0) {
			// TODO Auto-generated method stub
			return null;
		}
 
		@Override
		public Filter negate() {
			// TODO Auto-generated method stub
			return null;
		}
 
		@Override
		public Filter or(Filter arg0) {
			// TODO Auto-generated method stub
			return null;
		}
 
		@Override
		public Filter refine(Filter arg0) {
			// TODO Auto-generated method stub
			return null;
		}
      };//Fin du filtre
 
      //getContent va utiliser notre filtre pour créer une liste d'étudiants répondant
      //à nos critères.
      List resultat = racine.getContent(filtre);
      //On affiche enfin l'attribut classe de tous les éléments de notre list
      Iterator i = resultat.iterator();
      while(i.hasNext())
      {
         Element courant = (Element)i.next();
         System.out.println(courant.getAttributeValue("classe"));
      }
   }
}