Sujet Précédent Sujet Suivant

JTree avec root.userObject serializable

guitariste24 Messages postés 2 Date d'inscription vendredi 24 février 2006 Statut Membre Dernière intervention 23 novembre 2006 - 23 nov. 2006 à 23:49
cs_salmo Messages postés 2 Date d'inscription mercredi 23 avril 2003 Statut Membre Dernière intervention 3 mai 2012 - 3 mai 2012 à 03:55
Salutations !
J'ai crééer un JTree à partir d'un model que jai implementé.
Je fais la création des noeuds et la suppression.
Tout marche bien. ce que je veux, c'est de pouvoir sauvegardé mon noeud Root (serializable) et pouvoir reconstruire mon JTree.
Les objets de mon Jtree sont de type conception (donc le root aussi), le model ConceptionModel herite de la classe TreeModel.

je fais donc model = new ConceptionModel(Root);
tree = nwe JTree (model);

Donc a louverture de mon  objet serialisable qui est Root, la construction doit elle se faire directe du Jtree ?
Est ce que cela est possible ou faut il sauvegardé le model entier ?

merci

4 réponses

Réponse 1 / 4
Twinuts Messages postés 5375 Date d'inscription dimanche 4 mai 2003 Statut Modérateur Dernière intervention 14 juin 2023 111
24 nov. 2006 à 09:38
<meta http-equiv="CONTENT-TYPE" content="text/html; charset=utf-8" />
<title>
</title>
<meta name="GENERATOR" content="OpenOffice.org 2.0 (Linux)" />
<meta name="AUTHOR" content="bob bob" />
<meta name="CREATED" content="20061124;9241300" />
<meta name="CHANGED" content="16010101;0" />
<style type="text/css">
<!--
@page { size: 21cm 29.7cm; margin: 2cm }
P { margin-bottom: 0.21cm }
-->
</style>
Salut,

pour sérialiser
simplement le contenu d'un jtree tu peux faire comme suit :

1
- te faudra adapteer les methodes pour TON type de noeuds sois ici
j'utilise DefaultMutableTreeNode
2 - ici je ne sérialise
que le vecteur (j'ai déjà eu des prob avec la
sérialisation de jtree et cette méthode se révèle
la plus stable)

//voici deux méthode une pour recup
tout les noeuds du root dans un vecteur
//et un pour refaire un
root depuis un vecteur







private Vector<Object> getChilds(Object root) {
    if (root != null) {
        Vector<Object> child = new Vector<Object>(1);
        DefaultMutableTreeNode rootNode = (DefaultMutableTreeNode) root;
        int count = rootNode.getChildCount();
        if (count != 0)  child.add(rootNode);
        Enumeration en = rootNode.children();
        while (en.hasMoreElements()) {
            Object node = en.nextElement();
            if (((DefaultMutableTreeNode) node).children() != null)
                child.add(getChilds(((DefaultMutableTreeNode) node)));
        }
        if (count == 0) child.add(rootNode);
        return child;
    } else
        return null;
}

@SuppressWarnings("unchecked")
public static final DefaultMutableTreeNode createRoot(Vector<Object> vec) {
    DefaultMutableTreeNode node = new DefaultMutableTreeNode();
    node = (DefaultMutableTreeNode)vec.get(0);
    DefaultMutableTreeNode child;
    for (int i = 1; i < vec.size(); i++) {
        Object specifier = vec.get(i);
        if (specifier instanceof Vector)
            child = createRoot((Vector) specifier);
        else{
            //attention ce passage est critique il faut imperativement le faire
            //surtout apres une deserialisation de vecteur
            //sinon tu va restocker des residu de mémoire dedans et à force de seraliser tu vas
            //faire un StackOverflowError
            child = new DefaultMutableTreeNode();
            child = (DefaultMutableTreeNode)specifier;
        }
        node.add(child);
    }
    node.trimToSize();
    return (node);
}

maintenant la sérialisation et désérialisation :

public boolean save(String fileName) {
    if (fileName == null)
        throw new NullPointerException("null file name");
    if (fileName.trim().compareTo("") == 0)
        throw new IllegalArgumentException("empty file name");

    File file= new File(fileName);
    try {
        FileOutputStream fos = new FileOutputStream(file);
        ObjectOutputStream out = new ObjectOutputStream(fos);
        Vector vec = null;
        vec = getChilds(treeModel.getRoot());//treeModel est de type DefaultTreeModel
        vec.trimToSize();
        out.writeObject(vec);
        fos.close();
        out.close();
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}

@SuppressWarnings("unchecked")
public boolean load(String fileName) {
    if (fileName == null)
        throw new NullPointerException("null file name");
    if (fileName.trim().compareTo("") == 0)
        throw new IllegalArgumentException("empty file name");
    try {
        FileInputStream fis = new FileInputStream(fileName);
        ObjectInputStream in = new ObjectInputStream(fis);
        Vector<Object> vec = (Vector<Object>) in.readObject();
        vec.trimToSize();
        DefaultMutableTreeNode root = createRoot(vec);
        treeModel.setRoot(root);//treeModel est de type DefaultTreeModel
        in.close();
        fis.close();
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
     }
}

------------------------------------
"On n'est pas au resto : ici on ne fait pas dans les plats tout cuits ..."

WORA
0
Réponse 2 / 4
cs_salmo Messages postés 2 Date d'inscription mercredi 23 avril 2003 Statut Membre Dernière intervention 3 mai 2012
2 mai 2012 à 20:10
Salut Twinuts, j'ai repris ton code et je l'ai adapté selon mes besoins et ma compréhension. Ma classe Desarberiseur n'a qu'une méthode "desarberiser" qui sert à prendre la racine d'un Jtree et de la décomposer un ArrayList afin de la préparer à la sérialization (enregistrement en fichier).
Je n'arrive pas à descendre plus bas que la couche enfant alors qu'il y a une couche petit-enfants. Je sais qu'il me manque une réaffectation des couches mais je ne comprends comment le faire. Peux-tu m'aider? Voir plus bas pour les données.
Merci

public ArrayList<Object> desarberiser(Object root) {
if (root != null) {
ArrayList<Object> child = new ArrayList<Object>(1);
DefaultMutableTreeNode rootNode = (DefaultMutableTreeNode) root;
int count = rootNode.getChildCount();
if (count != 0) child.add(rootNode);
Enumeration enParent = rootNode.children();
while (enParent.hasMoreElements()) {
Object noeudParent = enParent.nextElement();
System.out.println("dans le while Parent");
System.out.println("noeudParent = "+noeudParent);
Enumeration enEnfant = ((DefaultMutableTreeNode) noeudParent).children();
while (enEnfant.hasMoreElements()){
Object noeudEnfant = enEnfant.nextElement();
System.out.println("dans le while Enfant");
System.out.println("noeudEnfant = "+noeudEnfant);
if (((DefaultMutableTreeNode) noeudEnfant).children() != null){
child.add((((DefaultMutableTreeNode) noeudEnfant).children()));
System.out.println("dans le if 1");
}
}
System.out.println("je sors du while enfant");
}
if (count == 0) child.add(rootNode);
return child;
} else
return null;
}
Voici les données qui compose root qui est passé à arberiseur. Ce ne sont pas les données qui causent problème car je les valide avec un JTree.

DefaultMutableTreeNode root = new DefaultMutableTreeNode("Famille");
DefaultMutableTreeNode Parent1 = new DefaultMutableTreeNode("Parent1");
DefaultMutableTreeNode Enfant1deParent1 = new DefaultMutableTreeNode("Enfant1deParent1");
DefaultMutableTreeNode Enfant2deParent1 = new DefaultMutableTreeNode ("Enfant2deParent1");
DefaultMutableTreeNode Enfant3deParent = new DefaultMutableTreeNode("Enfant3deParent 1");
DefaultMutableTreeNode Enfant4deParent = new DefaultMutableTreeNode("Enfant4deParent 1");
DefaultMutableTreeNode PetitEnfant1deparent4 = new DefaultMutableTreeNode("PetitEnfant1deparent4");
DefaultMutableTreeNode Parent2 = new DefaultMutableTreeNode("Parent2");
DefaultMutableTreeNode Enfant1deParent2 = new DefaultMutableTreeNode("Enfant1deParent2");
DefaultMutableTreeNode Enfant2deParent2 = new DefaultMutableTreeNode ("Enfant2deParent2");
Parent1.add(Enfant1deParent1);
Parent1.add(Enfant2deParent1);
Parent1.add(Enfant3deParent);
Enfant4deParent.add(PetitEnfant1deparent4);
Parent1.add(Enfant4deParent);
root.add(Parent1);
Parent2.add(Enfant1deParent2);
Parent2.add(Enfant2deParent2);
root.add(Parent2);
DefaultTreeModel m = new DefaultTreeModel(root);
Desarberiseur desar = new Desarberiseur((Object)root);
0
Réponse 3 / 4
Twinuts Messages postés 5375 Date d'inscription dimanche 4 mai 2003 Statut Modérateur Dernière intervention 14 juin 2023 111
2 mai 2012 à 23:00
Salut,

Je comprends pas trop... quand je reprends le code que j'ai donné plus haut et que je l'adapte pour ton exemple j'obtiens bien toute la petite famille: 

public class Desarberiseur {

  public static void main(final String[] args) {
    final DefaultMutableTreeNode root = new DefaultMutableTreeNode("Famille");
    final DefaultMutableTreeNode Parent1 = new DefaultMutableTreeNode("Parent1");
    final DefaultMutableTreeNode Enfant1deParent1 = new DefaultMutableTreeNode("Enfant1deParent1");
    final DefaultMutableTreeNode Enfant2deParent1 = new DefaultMutableTreeNode("Enfant2deParent1");
    final DefaultMutableTreeNode Enfant3deParent = new DefaultMutableTreeNode("Enfant3deParent 1");
    final DefaultMutableTreeNode Enfant4deParent = new DefaultMutableTreeNode("Enfant4deParent 1");
    final DefaultMutableTreeNode PetitEnfant1deparent4 = new DefaultMutableTreeNode("PetitEnfant1deparent4");
    final DefaultMutableTreeNode Parent2 = new DefaultMutableTreeNode("Parent2");
    final DefaultMutableTreeNode Enfant1deParent2 = new DefaultMutableTreeNode("Enfant1deParent2");
    final DefaultMutableTreeNode Enfant2deParent2 = new DefaultMutableTreeNode("Enfant2deParent2");
    Parent1.add(Enfant1deParent1);
    Parent1.add(Enfant2deParent1);
    Parent1.add(Enfant3deParent);
    Enfant4deParent.add(PetitEnfant1deparent4);
    Parent1.add(Enfant4deParent);
    root.add(Parent1);
    Parent2.add(Enfant1deParent2);
    Parent2.add(Enfant2deParent2);
    root.add(Parent2);
    final Desarberiseur desar = new Desarberiseur();
    desar.getChilds(root);
  }

  private ArrayList<Object> getChilds(final Object root) {
    if (root != null) {
      final ArrayList<Object> child = new ArrayList<Object>(1);
      final DefaultMutableTreeNode rootNode = (DefaultMutableTreeNode) root;
      final int count = rootNode.getChildCount();
      if (count != 0) {
        System.out.println("Node 0 : " + rootNode);
        child.add(rootNode);
      }
      final Enumeration en = rootNode.children();
      while (en.hasMoreElements()) {
        final Object node = en.nextElement();
        if (((DefaultMutableTreeNode) node).children() != null) {
          System.out.println("Node 1 : " + (node));
          child.add(getChilds((node)));
        }
      }
      if (count == 0) {
        System.out.println("Node 2 : " + rootNode);
        child.add(rootNode);
      }
      System.out.println("Return : " + child);
      return child;
    } else {
      System.out.println("Return : ");
      return null;
    }
  }
}


J'obtiens bien (ici c'est la dernière ligne qui est importante):

Node 0 : Famille
Node 1 : Parent1
Node 0 : Parent1
Node 1 : Enfant1deParent1
Node 2 : Enfant1deParent1
Return : [Enfant1deParent1]
Node 1 : Enfant2deParent1
Node 2 : Enfant2deParent1
Return : [Enfant2deParent1]
Node 1 : Enfant3deParent 1
Node 2 : Enfant3deParent 1
Return : [Enfant3deParent 1]
Node 1 : Enfant4deParent 1
Node 0 : Enfant4deParent 1
Node 1 : PetitEnfant1deparent4
Node 2 : PetitEnfant1deparent4
Return : [PetitEnfant1deparent4]
Return : [Enfant4deParent 1, [PetitEnfant1deparent4]]
Return : [Parent1, [Enfant1deParent1], [Enfant2deParent1], [Enfant3deParent 1], [Enfant4deParent 1, [PetitEnfant1deparent4]]]
Node 1 : Parent2
Node 0 : Parent2
Node 1 : Enfant1deParent2
Node 2 : Enfant1deParent2
Return : [Enfant1deParent2]
Node 1 : Enfant2deParent2
Node 2 : Enfant2deParent2
Return : [Enfant2deParent2]
Return : [Parent2, [Enfant1deParent2], [Enfant2deParent2]]
Return : [Famille, [Parent1, [Enfant1deParent1], [Enfant2deParent1], [Enfant3deParent 1], [Enfant4deParent 1, [PetitEnfant1deparent4]]], [Parent2, [Enfant1deParent2], [Enfant2deParent2]]]


Soit en prenant la dernière ligne ; qui représente la liste: 
Famille
  Parent1, 
    Enfant1deParent1
    Enfant2deParent1
    Enfant3deParent 1
    Enfant4deParent 1
      PetitEnfant1deparent4
  Parent2, 
    Enfant1deParent2
    Enfant2deParent2


-----

"On n'est pas au resto : ici on ne fait pas dans les plats tout cuits ..."

OoWORAoO
0
Réponse 4 / 4
cs_salmo Messages postés 2 Date d'inscription mercredi 23 avril 2003 Statut Membre Dernière intervention 3 mai 2012
3 mai 2012 à 03:55
Salut Twinuts, ton code fonctionne parfaitement. J'ai trouvé mon erreur...le flash tout d'un coup.
Lorsque j'ai repris ton code, j'ai modifié le nom de la méthode getChild() pour arberiser() sans modifier le getChild dans le code. Je croyais que ce getChild avait un rapport avec une classe alors je l'ai travaillé sans succès.

Je viens de remplacer "getChild" par "arberiser" partout dans le code et ça fonctionne super et en plus là je vois la récursivité.

Là je vais pouvoir avancer
Merci
0

Discussions similaires

[date - Time-Calendar] NOMBRE DE JOURS?
bidani -
danimo -

11 réponses
Recuperer le contenu d'un Arraylist quand celui est une classe créé par l'utilis
cs_reyman -
coq -

3 réponses
créer un tableau avec arraylist
ulysse00 -
ulysse00 -

13 réponses
JPanel + Titre
CHKDSK2K -
CHKDSK2K -

2 réponses
javadoc
asx9 -
asx9 -

4 réponses
Rejoignez-nous