ListIterator et ajout

Bonsoir,

Je réfléchis à un mini-programme très simplifié qui réalise des pseudos arbres généalogiques a partir d'une base de données. Pour expliquer, je vais prendre un exemple.

Soit le morceau de code suivant :
L'ArrayList listePers contient les noms des personnes sans ascendant. Pour notre exemple, supposons qu'elle contient Ned Flanders et Grandpa Simpson. Pour chaque membre de la liste, on va taper en BDD pour voir si cette personne a des descendants. On ajoute chacun de ces descendants à la liste.

Code:

---

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

PreparedStatement pst = null; ResultSet rs = null;   ListIterator<String> li = listePers.listIterator();   pst = c.prepareStatement(reqDescendants);   while(li.hasNext()) { String unNom = li.next();   pst.setString(1, unNom); rs = pst.executeQuery();   while(rs.next()) { String unAutreNom = rs.getString("nom");   li.add(unePersonne); } }

---

Ce code marchera très bien pour Ned Flanders : ses deux fils seront ajoutés sans problème.

Pour Grandpa ça marchera un peu moins bien : Homer et son frère seront bien ajoutés mais Lisa, Bart et Maggie ne le serons pas.

En effet, d'un point de vu technique, si j'ai bien compris la javadoc, Homer sera ajouté à la liste avant l'itérateur et ne sera donc jamais traité à son tour.

Vu la richesse de Java, il doit y avoir une solution que je ne connais pas ...

Merci d'avance.

Erm...

Code:

---

previous();

---

Non ?

J'y ai bien pensé. Mais cela pose au moins 1 problème :

Combien de previous dois-je faire ? Dans le cadre de mon exemple précèdent, Homer et son frère vont être ajoutés. Il faudra donc deux previous pour être sur d'avoir leur enfant ... mais pour un exemple avec 3 freres ... 5 freres, 0 ?

Pas faux. Suffirait de compter, mais c'est vrai que c'est moche.

Bon, pour un truc de ce genre, il ne te suffit pas d'une liste. Il t'en faut deux :
- Une qui contient les personnes que tu as fini d'analyser ou que tu es en train d'analyser, dans l'ordre.
Au début elle est vide, et tu y ajoutes les personnes au fur et à mesure.
- Une qui contient les personnes qu'il te reste à analyser.
Au début elle contient ceux qui n'ont pas d'ascendant. Puis tu en retires la première personne, et en l'analysant, tu ajoutes les descendants de cette personne au début de la pile des personnes à analyser.
Je recommande une LinkedList, car elle implémente Deque, une logique de pile LIFO, où on peut empiler et dépiler des choses.

Salut,


Je ne comprend pas trop ton algo : quel intérêt y a-t-il à charger les personnes par arbres généalogiques si c'est pour tous les stocker dans une simple liste !?

Il serait préférable d'opter pour une structure de donnée plus adapté à tes besoins...


a++

adiGuba : a cause d'un mappage objet/relationnel foireux sur lequel je peux plus agir ...

thelvin : j'ai réfléchis à ton idée de previous. Il y a autant de previous a faire qu'il y a d'itérations dans la boucle qui ajoute un descendant depuis la base de données (while (rs.next()). J'ai donc mis un li.previous a la fin de ce while (juste après li.add(unePersonne); ) et ça fonctionne. Merci.

Vu que ta liste n'a pas l'air d'être vraiment ordonnée, pourquoi ne pas simplement rappatrier tous les éléments de ta base ?

Parce que bon, prendre les éléments qui n'ont pas d'ascendant, et y ajouter tous leurs descendants de façon récursive, chez moi ça veut dire prendre tous les éléments ^^

Edit : ascendant / descendant

Rei Ichido : Je l'ai déjà expliqué : à cause du mappage objet <=> relationnel qui est foireux. Mais je vais détailler un peu.

J'avais volontairement simplifié dans mon premier post. Disons que mes personnes peuvent être de plusieurs types ... Donc lorsque je les sort de la base de données, je dois connaitre leur type pour faire appel au bon constructeur pour me construire le bon type de personne. Jusque là c'est logique. Leur type est indiqué selon un champ en BDD.

Le soucis, c'est que ce champ change si la personne a un ascendant. Toutes les personnes ayant un ascendant se retrouve avec le même champ. Donc on peut plus savoir de quel type elles sont et donc les mapper dans le programme Java. Mais on suppose qu'une personne de type A ne peut pas avoir un ascendant de type B (par exemple).

Donc il faut d'abord construire les personnes sans ascendant, puis, pour chaque, construire ses descendants.

Mais, je ne recherche plus de solution. La solution du previous de thelvin me convient même si je suis conscient du surcout en terme de requête BDD qu'elle entraine.