Problème Gestion Liste et fichiers txt
bonjour, suite à des essais de gestion de répertoire avec un jtree, je me suis lancé dans la comparaison de 2 répertoires distants sur un serveur.
Donc en gros;
Je prends avec un JFileChooser un path à analyser, et j'appelle une classe qui me génère un JTree en fonction du chemin d'accès fourni en paramètre(une chaine String):
Code:
1
2
| System.out.println("Remplissage du JTree Source");
scrollPane_jTreeSource.add(objPrinci.GenerationArbre(getJComboBox_TrueDir().getSelectedItem().toString(),"source")); |
La méthode "GenerationArbre" est la suivante:
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| public JTree GenerationArbre(String path,String type){
File directory;
DefaultMutableTreeNode rootTreeNode = new DefaultMutableTreeNode();
JTree arbre;
directory = new File(path);
arbre = new JTree();
if(type == "source"){
rootTreeNode.add(GenerationDirectory(directory, "source"));
arbre.setModel(new DefaultTreeModel(rootTreeNode,true));
}else if(type == "cible"){
rootTreeNode.add(GenerationDirectory(directory, "cible"));
arbre.setModel(new DefaultTreeModel(rootTreeNode,true));
}
return arbre;
} |
On peut voir dans cette méthode que je récupère un "DefaultMutableTreeNode" avec la méthode "GenerationDirectory", qui se définit par :
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
| private DefaultMutableTreeNode GenerationDirectory(File repertoire, String type){
DefaultMutableTreeNode noeud_directory = new DefaultMutableTreeNode(repertoire,true);
File[] liste = null;
int i = 0;
liste = repertoire.listFiles(); //récupération des fichiers et sous rep de root
if(liste!=null){
for(i = 0; i<liste.length; i++){
DefaultMutableTreeNode buffer_tree = null; //Création d'un noeud pour y stocker un nom de répertoire
if(liste[i].isDirectory()){ //Test si l'élement contenu dans liste est un répertoire ou un fichier,
if(type == "source"){
ecritureFichierTxt("Dossier Source : "+liste[i].getPath(),"C:/source.txt");
listeSource.add(liste[i].getPath());
buffer_tree = GenerationDirectory(liste[i],"source");
}
else if(type == "cible"){
ecritureFichierTxt("Dossier Source : "+liste[i].getPath(),"C:/cible.txt");
listeCible.add(liste[i].getPath());
buffer_tree = GenerationDirectory(liste[i],"cible");
}
}
else{ // Cas ou buffer est un fichier
buffer_tree = new DefaultMutableTreeNode(liste[i],false);
}
noeud_directory.add(buffer_tree);
}
}
return noeud_directory;
} |
Tout ca, fonctionne a merveille, ca reste pas forcément long à exécuter, même si je scanne des répertoires réseaux.
La suite, par contre pause problème. Après avoir généré mes JTree, j'appelle au niveau de mon ihm une méthode exécutant une comparaison de 2 dossiers:
Code:
1
2
| System.out.println("Lancement de CompareFile");
objPrinci.CompareFile(getJComboBox_TrueDir().getSelectedItem().toString(), getJComboBox_MAJDir().getSelectedItem().toString()); |
La méthode CompareFile, recoit en paramètres, les 2 chemins d'accès désiré :
Voici mon usine à gaz :aie: :
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
| public void CompareFile(String path_source, String path_cible){
List lst_source = new List();
List lst_cible = new List();
ecritureFichierTxt("Lancement de la comparaison","C:/Log.txt");
ecritureFichierTxt("Copie du buffer cible","C:/Log.txt");
ecritureFichierTxt("Debut de comparaison de dossiers","C:/Log.txt");
lst_source = listeSource;
for(int i=0;i<lst_source.getItemCount();i++){
ecritureFichierTxt(lst_source.getItem(i),"C:/rapport_lstSource.txt");
ecritureFichierTxt(""+lst_source.getItem(i).substring(path_source.length(),lst_source.getItem(i).length()),"C:/rapport_s.txt");
}
lst_cible = listeCible;
for(int j=0;j<lst_cible.getItemCount();j++){
ecritureFichierTxt(lst_cible.getItem(j),"C:/rapport_lstCible.txt");
ecritureFichierTxt(""+lst_cible.getItem(j).substring(path_cible.length(),lst_cible.getItem(j).length()),"C:/rapport_.txt");
}
int cpt_source = lst_source.getItemCount();
int cpt_cible = lst_cible.getItemCount();
for(int o = 0; o<cpt_source; o++){
for(int u = 0; u<cpt_cible; u++){
int resultat = lst_source.getItem(o).compareTo(lst_cible.getItem(u));
if(resultat == 0)
ecritureFichierTxt(lst_source.getItem(o),"C:/tutu.txt");
}
} |
Je précise que j'utilise des List, pourquoi? tout simplement, car durant la phase ou je génère mes jtree, j'écrivais dans un fichier texte, les noms de path répertoriés (afin de voir si mon algo lisait tous les dossiers ou non) et je stockais dans une List les paths répertoriés, afin de faire la comparaison sur les chaines de caractères.
Donc en gros si chaineA[i] == chaineB[j], le dossier A est à jour par rapport au dossier B....
Vous me suivez?
Le problème étant que si je scanne 2 dossiers "legers", ca fonctionne bien, mais si les dossiers sont trop volumineux (avec un grand nombre de sous dossiers), la comparaison des listes fonctionne mal, et je n'ai pas de fichiers txt d'écris à la fin.
avez vous une idée? j'ai mal codé une partie?
