Remplir un objet dans un tableau d objet

Version imprimable

Bonjour a tous,

j'ai un petit souci qui me torture l esprit depuis quelques temps.
En fait je voudrais remplir un objet dans un tableau d objet

voila déja mon fichier principale
Code:

1 2 3 4 5 6 7 8 class Node { String id_node; String question; String result; Node leftnode; Node rightnode; }
pour remplir mon tableau d objet avec les variables j'ai fait comme ceci en utilisant des arraylist qui elle même était rempli par une BDD
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 public String id_temp; public String question_temp; public String result_temp; List<String> ids = new ArrayList<String>(); List<String> questions = new ArrayList<String>(); List<String> results = new ArrayList<String>(); while (rs.next()) { id_temp = rs.getString(1); question_temp = rs.getString("question"); result_temp = rs.getString("result"); ids.add(id_temp); questions.add(question_temp); results.add(result_temp); } for (int cpt = 1; cpt < taille; cpt++) { nodes[cpt-1] = new Node(); nodes[cpt-1].id_node = ids.get(cpt-1); nodes[cpt-1].question = questions.get(cpt-1); nodes[cpt-1].result = results.get(cpt-1); }
Jusque la, pas de problème, mon tableau d objet se remplit correctement mais c est quand je veut remplir

Code:

nodes[].leftnode / rightnode

que cela coince :oops:

Grosso modo, je souhaite qu'a la fin, je puisse faire quelque chose du style

Code:

nodes[cpt-1].leftnode.question

Merci a vous

30/10/2013, 18h42
joel.drigo

Salut,

ta question n'a rien à voir avec les tableaux, et leur remplissage.

Tes deux variables :

Code:

nodes[cpt-1].leftnode

Code:

nodes[cpt-1].rightnode

sont des Node, comme nodes[cpt-1] : donc tu leur affectes une valeur de la même manière

Code:

nodes[cpt-1].leftnode= new Node();

Maintenant reste à savoir comment créer ce node... là, c'est toi qui sait...
Je suppose que tu as une requête à faire, similaire à celle qui de permet de construire tes nodes[]...

Fait une méthode à part peut être pour aller cherche le leftNode et le rightNode : je suppose que ton node courant doit avoir des informations à passer en paramètre de cette méthode pour construire la requête.

Code:

nodes[cpt-1].leftnode= creerNode(param1, param2, ...);

Peut être que ta requête principale récupère également les sous-nodes en question , auquel cas, il ne faut pas utiliser un tableau, mais plustôt une Map (clef id de node, valeur associée le node),
par exemple : quand tu trouves un node qui à un parent (tu devrais avoir l'id de ce parent), tu cherches ce parent dans la map (et tu le met dans left ou right), sinon tu l'ajoutes à ta map (puisqu'il n'a pas de parent).

Le résultat final est la liste de nodes directement présent de le "values" de la map.
30/10/2013, 18h51
biohazard401

Merci pour ta réponse ^^

En fait je souhaite que par exemple

Code:

nodes[cpt-1].rightnode

prenne la valeur de "id_node". Je sais pas si tu a deviné mais je suis en train de faire un arbre binaire avec des objets nœuds.

Le but du jeu c'est si l'utilisateur répond "oui" a la question, alors ont va aller a gauche en utilisant "leftnode" avec un nouveau objet Node qui a une nouvelle question et si il répond non, ont va a droite avec "rightnode".

Donc il faudrait insérer un "id_node" dans left/right node ... et c est la que cela coince.

Merci et désolé pour le mauvais titre :oops:
30/10/2013, 19h07
joel.drigo

Citation:

Envoyé par biohazard401

Merci pour ta réponse ^^

En fait je souhaite que par exemple

Code:

nodes[cpt-1].rightnode

prenne la valeur de "id_node". Je sais pas si tu a deviné mais je suis en train de faire un arbre binaire avec des objets nœuds.

oui, c'est évident que tu cherches à faire un arbre binaire

mmm :? id_node, c'est un String, pas un Node...

Ce que j'ai compris :
- tu fais une requête qui va chercher des nodes
- tu mets ces nodes dans un tableau
- ensuite tu veux créer les nodes droites et gauches de chacun de ces nodes

et pour ça, je peux pas deviner d'ou viennent ces noeuds (droite et gauche) ? S'ils sont dans ta base, il y a forcément un moyen de faire une requête pour les retrouver

Imaginons un système de gestion d'arbre binaire hypothétique - il pourrait être modélisé ainsi :

La table Node
- id (de type identity)
- question (de type varchar)
- id_node_left ( de type clef vers Node)
- id_node_right ( de type clef vers Node)

Ou encore :
La table Node :
- id ( de type identity)
- question (de type varchar )
- parent (de type clef vers Node)
- position (un char, L ou R, pour left ou right)

Comment est modélisé le tien ?
31/10/2013, 00h12
biohazard401

Ma BDD est faite comme cela:

id_node -> integer, PK et auto-incrémenter
question -> varchar
result -> varchar
id_left_node -> integer
id_right_node -> integer

en fait id_left/right me servent à aller chercher un nouvel id qui correspond a une question.

par exemple, mes premières lignes de ma BDD donne cela:
id: 1 - question : etes vous un homme ? - result : null - id left: 2 - id right:3
id: 2 - question : etes vous un artiste ? - result: null - id left : 4 - id right:5

dans l exemple, pour la première ligne, si l utilisateur répond "oui", ont va aller chercher la question qui a l'id n°2 et si il répond "non", ont va la prendre la question avec l'id n°3

Ce que je recherche a faire c est de trouver une égalité entre id_left/right et id_node. Si dans les 2 arraylist, ont trouve le même id, alors id_left/right va prendre comme valeur id.

Je veut faire comme cela parce que au fil du temps, la bdd va s'agrandir et je ne pourrais plus gérer manuellement ces données. Avec cette méthode, l'algo va faire ce que je souhaite automatiquement.

J'espère que j'ai étais assez claire :D

merci

Ok, j'ai un modèle maintenant :P

Donc, le problème à régler c'est que quand tu lis un node, le node gauche et le node droit ne sont pas forcément déjà lu.

Du coup, c'est pas évident de pouvoir construire les nodes droites et gauches, tant qu'on les a pas lus.

La solution la plus simple est de charger toutes les infos dans une map, en utilisant une classe intermédiaire (un sorte de faux node), et de construire les nodes à la fin. Bon tu fais un truc dans le genre en utilisant 3 listes, c'est pas le plus simple à manipuler, mais soit, ça peut marcher. Il te faut toutefois 2 listes de plus, une pour les ids de noeuds left, une pour les ids de noeuds right

Ou alors tu crées un ResultSet qui peut fonctionner dans les deux sens (forward et backward), et tu te déplaces dans le résultset pour chercher les noeuds left et right, puis tu reviens à la position du node courant, pour continuer le chargement : il te faudra quand même stocker tes id dans un set pour "sauter" les noeuds déjà lus en tant que left ou right d'un autre

Donc en se basant sur le code que tu as fait, tu as trois listes, ajoutes en 2 pour les nodes left et right :

tu peux créer une méthode :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 public static Node creerNode(String id, List<String> ids, List<String> questions, List<String> results, List<String> left, List<String> right) { // on cherche les infos correspondant à l'id : int index = ids.indexOf(id); if ( index<0 ) { // erreur à gérer : pas de node avec cet id return null; } Node node = new Node(); node.id_node = id; node.question = questions.get(id); node.result = results.get(id); String leftId = left.get(id); if ( leftId!=null ) node.leftNode = creerNode(leftId, ids, questions, results, left, right); String rightId = right.get(id); if ( rightId!=null ) node.rightNode = creerNode(rightId , ids, questions, results, left, right); } }
Avec une map, en partant du principe que les fils sont toujours placés après les parents (sinon, ça va être galère : il faudrait déterminer d'abord tous les nodes root (ceux sans parent)) :

d'abord une classe pour charger les infos :
Code:

1 2 3 4 5 6 public class InfoNode { public String question; public String result; public String leftId; public String rightId; }
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 public String id_temp; public String question_temp; public String result_temp; Map<String, InfoNode> infos=new LinkedHashMap<String, InfoNode>(); while (rs.next()) { InfoNode info = new InfoNode(); info.question = rs.getString("question"); info.result = rs.getString("result"); info.leftId = rs.getString("id_left_node"); info.rightId = rs.getString("id_right_node"); infos.put(rs.getString(1), info); } // fonctionne si les nodes fils sont après leur parent dans le resultset (sinon, on détermine d'abord les root, on les mets dans une liste, puis on parcout cette liste) List<Node> nodeList=new ArrayList<Node>(); while( !infos.isEmpty() ) { String id = infos.keySet().iterator().next(); nodeList.add( creerNode(id, infos)); } nodes = nodeList.toArray(new Node[nodeList.size()]); }
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 public static Node createNode(String id, Map<String, InfoNode> infos) { InfoNode info = info.remove(id); // on supprime le node, comme ça il ne sera pas retraité if ( info==null ) { // erreur à gérer return null; } Node node = new Node(); node.id_node = id; node.question = info.question; node.result = info.result; if ( info.leftId!=null ) { node.leftNode = createNode(info.leftId, infos); } if ( info.rightId!=null ) { node.rightNode = createNode(info.rightId, infos); } return node; }
PS: j'ai tapé directement dans le forum, il l'y a peut être des fautes de frappes... et des trucs qui manquent :P je te laisse remplire les trous :P

31/10/2013, 01h09
joel.drigo

Citation:

Envoyé par biohazard401

Ce que je recherche a faire c est de trouver une égalité entre id_left/right et id_node. Si dans les 2 arraylist, ont trouve le même id, alors id_left/right va prendre comme valeur id.

ça par contre j'ai rien compris

Sinon, j'ai pensé à un autre truc :

En stockant dans ton node, la map de nodes, et en stockant les id de left et right, et en utilisant une méthode getLeft() et getRight(), plus de problème de précédence...

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
class Node {
    private final static Map<String, Node> nodes=new HashMap<String,Node>();
 
   private String id;
   private String question;
   private String result;
   private String left;
   private String  right;
 
    public Node(String id, String question, String result, String left, String right) {
       this.id=id;
       this.question=question;
       this.result=result;
       this.left=left;
       this.right=right;
       map.put(id, this);
}
 
public String getId() {
    return id;
}
 
public String getQuestion() {
   return question;
}
 
public String getResult() {
   return result;
}
 
public Node getLeftNode() {
    return map.get(left);
}
 
public Node getRightNode() {
    return map.get(right);
}
 
}

et la lecture :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
List<Node> nodeList=new ArrayList<Node>();
 
while (rs.next()) {
    Node node = new Node(rs.getString(1),
                           rs.getString("question"),
                          rs.getString("result"),
                          rs.getString("id_left_node"),
                           rs.getString("id_right_node"));
 
   nodeList.add(node);
}
Node[] nodes = nodeList.toArray(new Node[nodeList.size()]);

Salut,

Déja merci pour toutes ces infos (sa ma appris de nouvelles choses), par contre je pense que l ont s'égare un petit peu de ce que je voulais faire à la base.

En effet avec ta première réponse, j'ai fait un bond en avant :D

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
for (int cpt = 1; cpt < taille; cpt++)
     {
        nodes[cpt-1] = new Node();
        nodes[cpt-1].id_node = ids.get(cpt-1);
	nodes[cpt-1].question = questions.get(cpt-1);
	nodes[cpt-1].result = results.get(cpt-1);
 
        nodes[cpt-1].leftnode = new Node();
	nodes[cpt-1].leftnode = nodes[cpt-1];
 
	nodes[cpt-1].rightnode = new Node();
        nodes[cpt-1].rightnode = nodes[cpt-1];
     }

c'est surtout la dernière parti

Code:

1
2
3
4
5
6
 
nodes[cpt-1].leftnode = new Node();
nodes[cpt-1].leftnode = nodes[cpt-1];
 
nodes[cpt-1].rightnode = new Node();
nodes[cpt-1].rightnode = nodes[cpt-1];

qui a évolué et c'est ce que je recherche. En faisant un sysout

Code:

1
2
 
System.out.println("notre liste d'objet de question, partie left_node : "  + nodes[t].leftnode.question);

il me renvoie

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
notre liste d'objet de question, partie left_node : Etes vous un homme ?
notre liste d'objet de question, partie left_node : Etes vous un artiste ?
notre liste d'objet de question, partie left_node : Etes vous francaise ?
notre liste d'objet de question, partie left_node : Etes vous un chanteur ?
notre liste d'objet de question, partie left_node : Etes vous dans la politique?
notre liste d'objet de question, partie left_node : Etes vous un connu ?
notre liste d'objet de question, partie left_node : Etes vous le cinema ?
notre liste d'objet de question, partie left_node : null
notre liste d'objet de question, partie left_node : null
notre liste d'objet de question, partie left_node : null
notre liste d'objet de question, partie left_node : null
notre liste d'objet de question, partie left_node : null
notre liste d'objet de question, partie left_node : null
notre liste d'objet de question, partie left_node : null

Et c'est exactement ce que je chercher à faire, maintenant reste plus qu'a faire le tri entre left et right parce que pour l'instant il ne fait pas la différence.

Un grand merci, pour ta patience et pour toutes les infos :ccool:

31/10/2013, 13h48
joel.drigo

Citation:

Envoyé par biohazard401

nodes[cpt-1].leftnode = new Node();
nodes[cpt-1].leftnode = nodes[cpt-1];

nodes[cpt-1].rightnode = new Node();
nodes[cpt-1].rightnode = nodes[cpt-1];

enfin, avec ce code, tu n'as pas un arbre binaire non plus : tu as juste leftnode = rightnode = node courant. Les new Node() sont inutiles.
31/10/2013, 15h51
biohazard401
Effectivement, en enlevant
Code:

1 2 3 nodes[cpt-1].leftnode = new Node(); nodes[cpt-1].rightnode = new Node();
et en gardant
Code:

1 2 3 nodes[cpt-1].leftnode = nodes[cpt-1]; nodes[cpt-1].rightnode = nodes[cpt-1];
J'arrive au même résultat :oops:

Donc, la maintenant je suis dans le vrai ? ou je suis encore à l'ouest et il faut que j'utilise ta méthode ?

Merci
31/10/2013, 15h56
joel.drigo
Citation:
Envoyé par biohazard401

Effectivement, en enlevant

Code:

1 2 3 nodes[cpt-1].leftnode = new Node(); nodes[cpt-1].rightnode = new Node();

et en gardant

Code:

1 2 3 nodes[cpt-1].leftnode = nodes[cpt-1]; nodes[cpt-1].rightnode = nodes[cpt-1];

J'arrive au même résultat :oops:

Donc, la maintenant je suis dans le vrai ? ou je suis encore à l'ouest et il faut que j'utilise ta méthode ?

Merci
Code:

nodes[cpt-1].leftnode = nodes[cpt-1];

cà se lit :
- j'ai dans la cas de tableau nodes d'index cpt-1, une instance de Node
- je dis que la variable leftnode de cette instance doit contenir ce que contient la case du tableau nodes d'index cpt-1

c'est comme si tu avais écrit :

Code:

x.leftnode = x;

avec x une variable de classe Node

Je viens d'utiliser ta méthode

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
List<Node> nodeList=new ArrayList<Node>();
 
while (rs.next()) {
    Node node = new Node(rs.getString(1),
                           rs.getString("question"),
                          rs.getString("result"),
                          rs.getString("id_left_node"),
                           rs.getString("id_right_node"));
 
   nodeList.add(node);
}
Node[] nodes = nodeList.toArray(new Node[nodeList.size()]);

C'est du bonheur en boite, tout est a sa place mais left/right ne sont plus des objets Node. Je ne peut plus faire par exemple

Code:

1
2
 
nodes[cpt].leftnode.question

Merci

Citation:
Envoyé par biohazard401
Je viens d'utiliser ta méthode
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 List<Node> nodeList=new ArrayList<Node>(); while (rs.next()) { Node node = new Node(rs.getString(1), rs.getString("question"), rs.getString("result"), rs.getString("id_left_node"), rs.getString("id_right_node")); nodeList.add(node); } Node[] nodes = nodeList.toArray(new Node[nodeList.size()]);
C'est du bonheur en boite, tout est a sa place mais left/right ne sont plus des objets Node. Je ne peut plus faire par exemple
Code:

1 2 nodes[cpt].leftnode.question
Merci
en fait, pour résoudre plus facilement le problème des liens, j'ai du faire des méthodes plutôt que des attributs de classe Node dans la classe Node :

Donc il faut simplement écrire :
Code:

1 2 nodes[cpt].getLeftNode().getQuestion();
Enfin tu peux écrire aussi :
Code:

1 2 nodes[cpt].getLeftNode().question;
parce que toutes les classes sont dans le même package... mais c'est une mauvaise habitude à ne pas prendre que d'accèder aux attributs privés d'une classe en n'utilisant pas les accesseurs

03/11/2013, 12h38
biohazard401
Salut,

Déjà désolé pour le petit retard mais j'avais quelques souci avec mon pc (sale bête !!)

Par contre un grand grand merci pour m'avoir aider et de ne pas m'avoir rembarrer avec mes questions qui pouvais paraître stupide parce que grâce a toi, tout marche a merveille ... je peut faire "mumuse" en faisant par exemple
Code:

1 2 nodes[cpt].getLeftNode().getRightNode().getQuestion();
La prochaine étape et d'automatiser l'insertion à la BDD après chaque partie, mais sa je me démerde tout seul, c'est pas le plus compliqué ^.

Encore merci ;)