Activité Lire un fichier XML et rechercher des objets dans une liste

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
package ch.epaifribourg.ict.m100;

import java.io.File;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.List;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import org.w3c.dom.Node;
import org.w3c.dom.Element;


public class ContactManager {

    private static class Person {
        int id;
        String firstname = "";
        String lastname = "";
        String street = "";
        String postalCode = "";
        String city = "";
        String email = "";
    }

    public static void main(String[] args) throws Exception {

        // Initialise une chaîne de caractère avec le chemin du fichier XML.
        // Attention : Les backslashes (\) du chemin Windows sont dédoublés
        // car dans une chaîne de caractères, le backslash est le caractère
        // d’échappement qui permet d’écrire des caractères spéciaux tels que
        // \r (carriage return), \n (line feed) ou \t (tab).
        String filename = "C:\\Users\\frossardj\\Documents\\data.xml";

        // Crée un objet de type File avec le chemin du fichier XML.
        File xmlFile = new File(filename);

        // Charge les données des personnes qui se trouve dans le fichier XML
        // dans un objet de type List de Person et affecte une référence à cet
        // objet à la variable personList.
        List<Person> personList = loadPersonDataFromXml(xmlFile);

        // Affiche le résultat dans la sortie standard (System.out).
        printPersonList(System.out, personList);
    }

    /**
     * Charge les données des personnes qui se trouvent dans le fichier XML dans un objet 
     * de type List de Person et renvoie l’objet.
     *
     * @param file le fichier XML à lire
     * @return l’objet person correspondant.
     */
    private static List<Person> loadPersonDataFromXml(File file) throws Exception {

        // Crée un tableau dynamique.
        List<Person> personList = new ArrayList<>();

        // Crée un objet Document qui représente les données du fichier XML
        // sous la forme d’une hiérarchie d’objets de type Node. Un objet de
        // type nœud peut représenter aussi bien un élément, qu’un nœud
        // de texte ou un attribut.
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder builder = factory.newDocumentBuilder();
        Document doc = builder.parse(file);
        doc.getDocumentElement().normalize();

        // Recherche tous les elements <person>
        NodeList personNodeList = doc.getElementsByTagName("person");

        // Pour chaque élément XML de la liste
        for (int i = 0; i < personNodeList.getLength(); i = i + 1) {
            Node node = personNodeList.item(i);

            if (node.getNodeType() == Node.ELEMENT_NODE) {
               
                // Récupère l'élément
                Element personElement = (Element)node;

                // Crée un nouvel objet de type Person
                Person person = new Person();

                person.id = Integer.parseInt(personElement.getAttribute("id"));
                person.firstname = personElement.getElementsByTagName("firstname").item(0).getTextContent();
                person.lastname = personElement.getElementsByTagName("lastname").item(0).getTextContent();
                person.postalCode = personElement.getElementsByTagName("postal-code").item(0).getTextContent();
                person.street = personElement.getElementsByTagName("street").item(0).getTextContent();
                person.city = personElement.getElementsByTagName("city").item(0).getTextContent();
                person.email = personElement.getElementsByTagName("email").item(0).getTextContent();
                
                // Ajoute la personne à la liste
                personList.add(person);
    
            }
        }

        // Renvoie la référence à l’objet personList
        return personList;
    }

    /**
     * Ecrit les élément d’une liste d'objet de type Person dans le flux de sortie
     * passé en paramètre.
     *
     * @param out le flux de sortie
     * @param personList la liste d'objet de type Person
     */
    private static void printPersonList(PrintStream out, List<Person> personList) {

        for (int i = 0; i < personList.size(); i = i + 1) {
            Person person = personList.get(i);
            printPerson(out, person);
        }
    }

    /**
     * Ecrit les données d’un objet de type Person dans le flux de sortie
     * passé en paramètre.
     *
     * @param out le flux de sortie
     * @param person l’objet de type Person
     */
    private static void printPerson(PrintStream out, Person person) {

            out.printf("(%d) %s %s, %s, %s %s\r\n",
                    person.id,
                    person.firstname,
                    person.lastname,
                    person.street,
                    person.postalCode,
                    person.city);
    }
}

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
    /**
     * Cherche dans une liste de personnes les personnes dont le nom est celui
     * passé en paramètre et renvoie la liste des personnes trouvées.
     * Si aucune personne n'a été trouvée, la fonction renvoie une liste vide.
     *
     * @param personList la liste de personnes
     * @param name le nom de la personne recherchée
     * @return l'objet correspondant à la personne
     */
    private static List<Person> findPersonByName1(List<Person> personList, String name) {

        // Crée un nouveau tableau dynamique pour y stocker les
        // personnes qui correspondent au critère de recherche
        List<Person> result = new ArrayList<>();

        // Répète pour chaque personne de la liste.
        for (int i = 0; i < personList.size(); i = i + 1) {

            // Récupère l'objet de type Person.
            Person person = personList.get(i);

            // Teste si le nom de la personne correspond
            // à celui passé en paramètre.
            if (person.lastname.equals(name)) {
                // Ajoute la personne à la liste des
                // personnes trouvées.
                result.add(person);
            }
        }

        // Renvoie la liste des personnes trouvées.
        return result;
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
    ...

    public static void main(String[] args) throws Exception {

        ...

        // Demande à l'utilisateur de saisir le nom de la personne recherchée.
        System.out.printf("Veuillez saisir le nom d’une person : ");
        Console console = System.console();
        String name = console.readLine();

        // Recherche les personnes dans liste.
        List<Person> result = findPersonByName1(personList, name);

        // Affiche le résultat dans la sortie standard (System.out).
        printPersonList(System.out, result);
    }

    ...

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
    ...

    public static void main(String[] args) throws Exception {

        ...

        // Demande à l'utilisateur de saisir le nom de la personne recherchée.
        System.out.printf("Veuillez saisir le nom d’une person : ");
        Console console = System.console();
        String name = console.readLine();

        // Mesure le temps avant l'exécution
        long startTime = System.nanoTime();

        // Recherche les personnes dans liste.
        List<Person> result = findPersonByName1(personList, name);

        // Mesure le temps après l'exécution
        long endTime = System.nanoTime();

        // Affiche le résultat dans la sortie standard (System.out).
        printPersonList(System.out, result);

        // Affiche le temps d'exécution
        System.out.printf("\nTemps d'exécution : %d ns\n", endTime - startTime);
    }

    ...