Arbres en JAVA

Version imprimable

07/06/2010, 14h10
ManusDei

Arbres en JAVA

Bonjour,

je cherche a faire des arbres en Java.
Pour être exact, j'ai des objets rangés dans des Hashmap (par type de classe), et je veux, quand je ne trouve pas un objet dans sa Hashmap, pouvoir chercher dans les classes filles.

Sauf que pour ça j'ai besoin de construire un arbre pour représenter les héritages, et donc connaitre les classes filles.

J'arrive à trouver la classe mère (pas compliqué), et donc je veux faire un arbre avec les héritages, mais je ne trouve pas de tutoriel clair sur les arbres en java.

Est-ce que quelqu'un sait où je peux en trouver un, ou serait disposé à m'expliquer ?
07/06/2010, 15h16
legentil

Bonjour,

Je ne comprend pas bien ton problème en fait, c'est quoi que tu n'arrive pas à avoir? ta structure d'héritage? ou juste tu n'arrive pas à l'afficher dans un arbre graphique?

Si ce que tu veux, c'est trouver toute les classes filles d'une classe donnée par programmation, je ne pense pas que ce soit possible...

Ensuite, si tu a déjà une liste de toute tes classes et que tu veux juste connaitre les structures d'héritage qu'il y a entre elles, tu peux récupérer la classe mère d'une classe (méthode getSuperclass de la classe Class), et ainsi faire ton arbre en faisant des feuilles vers la racine...

voilà en espérant que ça t'aidera à avancer !

J'ai déjà mes listes de classes, mon problème est que je ne comprend pas vraiment comment faire un arbre. A ce que j'en ai vu, je suis obligé de passer par un JTree, car il n'y a pas d'autre classe d'arbres.

Mais je ne trouve pas de tutoriel clair sur la manière de l'utiliser.

Avec MutableTreeNode, je crée des nœuds, mais qui sont initialisés à null, et que je n'arrive pas à instancier à autre chose, par exemple pour faire un arbre d'entiers, ou un arbre de String.

En bref j'y comprend rien :mrgreen:

Je me suis fait un classe pour enregistrer l'arbre
Code:

1 2 3 4 5 6 7 8 9 10 11 12 package trees; import javax.swing.JTree; public class MyTree { public JTree tree; public MyTree(){ tree = new JTree(); } }
Ainsi qu'une classe de test
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 package trees; import javax.swing.tree.DefaultMutableTreeNode; import javax.swing.tree.MutableTreeNode; import org.junit.Test; public class MyTreeTest { @Test public void createTree() { MyTree mytree = new MyTree(); MutableTreeNode node1 = null; MutableTreeNode node2 = null; MutableTreeNode node3 = null; MutableTreeNode node4 = null; node2.setParent(node1); node3.setParent(node1); node4.setParent(node2); } }

Les JTree sont fait pour faire des arbres graphiques (dans swing), pas juste pour avoir des représentations mémoires de l'arbre (ce que tu veux avoir, à ce que j'ai compris)

Je partirai plus sur une solution comme ça :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 public class ClasseStructuree{ Class<?> maClasse; ArrayList<ClasseStructuree> classesFilles = new ArrayList<ClasseStructuree>(); public ClasseStructuree(Class<?> maClasse){ this.maClasse = maClasse; } public void ajouterClasseFille(ClasseStructuree classeFille){ classesFilles.add(classeFille); } }
En ajoutant des accesseurs sur la classe et la liste de classes filles, ça te permettra d'avoir ton arborescence de classes en mémoire et d'accéder facilement à toutes les classes filles d'une classe !

à plus !

07/06/2010, 17h09
sleroux
Bonjour ManusDei,

Si j'ai bien compris ton problème, tu souhaites pouvoir stocker des objets dans une HashMap, et les retrouver par leur classe - ou une de leurs classes parentes.

De facto, ça ne peut être utilisé que dans le cas où tu sera amené à ne stocker simultanément qu'une instance maximum de chaque classe (singletons?). Or, ça soulève un problème intéressant. Imaginons la hiérarchie de classes suivante:
Code:

1 2 3 4 5 6 7 8 Object | +-- A | +-- AA | +-- AB
Imaginons qu'on stocke dans ta table une instance de AA et une instance de AB, laquelle des deux doit-on retrouver quand on cherche une instance de A?

[hr]

Avec les réserves évoquées ci-dessus, tu peux peut-être "contourner" ton problème en stockant dans ta HashMap une entrée pour chaque classe ancêtre des objets insérés (une instance de AB insère 3 entrées: une avec la clé AB, l'autre avec A, la troisième avec Object).

- Sylvain
08/06/2010, 09h49
ManusDei

Effectivement, là je pars sur une gestion par Hashmap.

Code:

private HashMap <Class, Vector<Class>> inheritance;

Donc là j'ai une HashMap qui prend en entrée un type de classe, et qui me renvoie un vecteur avec les classes qui hérite de cette classe (pour régler le problème de AA et AB).

Je suis en train de regarder si je peux ajouter des éléments à mon vecteur sans casser la HashMap, je mettrais ma solution quand j'aurais trouvé.

Stocker une entrée pour chaque classe Ancêtre ne m'arrange guère, je cherche à récupérer les classes Enfant, passer par l'Ancêtre doit être un peu long. Mais ce n'est pas exclus, si l'autre situation s'avère trop compliquée à mettre en place.

Edit : j'ai une première version qui fonctionne, maintenant je vais rajouter de la récursivité, pour récupérer les classes filles des filles.

Alors, ma solution.

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
package trees;
 
import java.util.HashMap;
import java.util.HashSet;
import java.util.Vector;
 
public class MyTree {
 
    // Key of Hashmap is Class, the values are the Class that inherit directly from Key
    private HashMap <Class, HashSet<Class>> inheritance = new HashMap<Class, HashSet<Class>>();
 
    /**
     * This function adds a given Class type to inheritance HashMap
     * It create an entry with it's superclass if none exists, or is added to convenient HashSet
     * If type is already taken into account, nothing happens
     * @param type : Class type to be added to inheritance attribute
     */
    @SuppressWarnings("unchecked")
    public void setInherits(Class type){
        HashSet<Class> v;
        // if key does not exist, create a new empty HashSet, to be filled below
        if (getInheritance(type.getSuperclass()) == null)
            inheritance.put(type.getSuperclass(), new HashSet<Class>());
        // get the HashSet corresponding to the given Key
        v=inheritance.get(type.getSuperclass());
        // adds type to HashMap, before adding modified (or not) HashSet to HashMap 
        v.add(type);
        inheritance.put(type.getSuperclass(), v);
    }
 
    /**
     * Get all Class types that directly inherit from given type
     * @param type : Class whose children are wanted
     * @return : A HashSet that contains all children from parameter Class type, null if there are no children
     */
    @SuppressWarnings("unchecked")
    public HashSet<Class> getInheritance(Class type){
        HashSet<Class> hs = null;
        if (inheritance.containsKey(type))
            hs = inheritance.get(type);
        return hs;
    }
 
}

Pour la récursivité, elle est gérée lors de l'appel, avec des

Code:

1
2
3
4
5
6
if (t == null && getInheritance(type) != null){
      for(Class types : getInheritance(type)){
          t = (T) get(id, types); // appel recursif
          if (t != null) break;
     }
}