Bonjour !
 
Dans un projet que j'ai en cours, je voudrais pouvoir créer une sdd reflétant une arborescence de fichiers (en Java).
Cette arborescence comprendra donc des dossiers qui contiendront soit une donnée dite "Source", soit une référence (ou raccourcis) vers cette donnée.
 
Créer cette arborescence n'est pas vraiment ce qui m'inquiète (quoique ), mais plutôt le "maintien" de l'arborescence.
Je m'explique :
 
Imaginez que vous aillez un dossier racine qui contienne tous vos fichiers.
Sous ce dossier racine se trouve des dossiers fils, petits-fils, etc... (jusqu'à un niveau de 5 ou 6 descendants max je pense).
Ces dossiers fils ne contiennent pas la donnée initiale, mais un raccourcis - ou référence - vers cette donnée. Plusieurs références peuvent pointer vers le même fichier source.
 
Ce que je voudrais donc, c'est que lors de la création d'un fichier, on décide de l'ajouter (manuellement) à tel ou tel sous dossier en tant que référence, mais surtout que lors de la suppression d'un fichier source, toutes les références disparaissent. (histoire d'éviter un raccourcis mort).
 
Je pense que je serai capable de le faire de facon lourde et massive (en gardant associé à chaque fichier source une liste de toutes ses références pour pouvoir ensuite les supprimer) mais ce code est destiné à tourner sur une petite machine sans grandes ressources...
 
Donc pourriez vous me donner quelques pistes ?
 
Merci !    
 
P.S : je débute en prog Java, ne soyez pas trop abstraits pour moi svp

comme ça là, les yeux à demi-ouverts, je dirai avec des HashTable. une HashTable est un objet représentant un couple (clé, valeur), sachant que pour la clé tu mets ce que tu veux (un int, un String, etc.) et pour la valeur pareil (String, etc.)
dans ton cas, je vois bien le nom de ton dossier comme clé, et comme valeur une hashtable référençant la liste des dossiers et fichiers contenus dans le dossier représenté par la hashtable
tu as ainsi le principe d'arborescence: une hastable représente un fichier/dossier
dans le cas d'un dossier, la valeur du couple (clé, valeur) est une hashtable, et dans le cas d'un fichier, la valeur vaut null, ou bien pourquoi pas un objet File

Ok ok je comprends bien ce que tu me dis (si on remplace le dernier "dossier" par "fichier" ).
J'avais déjà pensé à ce type de structure mais, soit elle ne le permet pas, soit je ne vois (comprends) pas comment elle permet de maintenir rapidement mon arborescence.
Je m'explique :
 
En quoi la HashTable permet elle de retrouver rapidement les références à mon élément source ?    
Pour donner un ordre de grandeur, il peut y avoir des centaines de fichiers sources à supprimer d'un coup, et chacun de ces fichiers peut être référencé 5 ou 6 fois. Si on fait le calcul, le nombre de références à supprimer devient tout de suite trés grand...
 
Donc je ne mets pas en doute que si à une référence on associe l'objet source (soit, pour le fichier001, une référence sera de la forme ("ref005Tofichier001","fichier001" ) ) on peut retrouver facilement toutes les références par une recherche d'objet sur la HashTable racine, mais est ce que ce sera rapide ??
 
La solution que tu me proposes est peut être la meilleure, mais je me demande si il n'y a pas quelque chose de plus rapide (la recherche d'objet identique au milieu de milliers de référence et en naviguant de Hastable en HashTable risque de prendre du temps sur une toute petite machine) de faisable.
 
voila !  

Salut
 
Je pense que tu devrais passer par des fichiers xml, c'est le top pour gerer les arborescences. Surtout que java possede une API de gestion XML qui tourne bien. Je l'utilise et c'est impec.

Salut vuid !
 
Ce que tu dis m'intéresses
 
L'XML est effectivement une solution, mais penses-tu que le traitement de fichiers xml sera plus rapide que l'utilisation d'une sdd java ? (c'est une question, pas une remarque )

 
Par contre je me pose une question :  
 
Toi tu fairais un fichier XML par dossier ? Parceque par exemple, si je veux afficher le contenu de tel ou tel dossier, si je dois me faire tout le parsage d'un gros fichier XML, ca n'est pas trés efficace... (en l'état de mes connaissances )
 
 
trevor >>> ca veut dire que tu restes sur ta position ? pourrais tu m'expliquer pourquoi ?
 
Merci !  

fait
 

 
avec un fonction récursive, la recherche d'un élément à modifier ou supprimer se fait en 5 lignes
 
en ce qui concerne la rapidité, cela ne me semble pas des opérations très couteuses. une fois la sdd mise en place, il n'y a pas d'instanciation ou de trucs du même style. bon, même si je suis loin d'être un pro, je vois pas en quoi ça sera lent.
dans l'absolu, on reste en java, donc avec une certaine lenteur d'exécution (globalement) par rapport à des langages type c. si effectivement la rapidité est primordiale, je changerai à ce moment-là de langage d'implémentation si j'étais toi. mais apparemment, le langage t'est imposé, si je ne m'abuse ?
et puis, la rapidité, ca se teste !

 
Autre remarque : Si je veux maintenir mon arborescence, lors de la suppression de fichier, est-ce vraiment rapide :-)
Pourrais tu expliciter un peu plus la méthode de gestion que tu utiliserais ?
 
Trevor : Je ne suis pas (du tout) un pro non plus, et donc j'ai du mal à me faire une idée de ce genre de choses. Sinon oui, Java obligatoirement (ca ne m'est pas imposé, ca s'impose tout seul par d'autres contraintes ).
 
Mwais, apparemment, pas de solution miracle    
 
Si d'autres personnes ont des suggestions, qu'elles n'hésitent pas !

Le xml ça marche avec des moeuds et des fils.
A la lecture du fichier il créé tous les noeuds avec tous les fils des noeuds en memoire(Element). Quand tu veux supprimer un fils d'un noeud, il suffit de rechercher le noeud parent et de faire un removeChild(Object o) sur ce parent : c'est hyper rapide,mais il faut ensuite recreer le fichier avec cequ'il ya en memoire. Mais meme l'etape de regeneration du fichier est assez rapide (c'est à dire à partir de ce que tu as en memoire, generer le code xml, puis l enregistrer). Peut etre pas tres clair ce que je te dit, mais le xml c'est super et c'est tres souvent utilisé pour l'arborescence.