Discussion :

[Freud44]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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?

[baos!]

J'ai pas tout suivi , mais si c'est un pb de performance (dossiers volumineux), je vois 2 points améliorable :
1. utiliser une librairie comme log4j pour les logs, cela utilise un cache et permet une écriture de log relativement rapide (a moins que la méthode ecritureFichierTxt soit elle même optimisée).

2. Dans la comparaison des 2 listes, plutôt que

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
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));
           ...
    }
}

qui va scanner la seconde liste autant de fois qu'il y a d'éléments dans la première O(n²), faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
Collections.sort(cpt_source);
Collections.sort(cpt_cible);
int o = 0;
int u = 0;
while (o < cpt_cible.size() && u < cpt_cible.size() ) {
     int resultat = lst_source.getItem(o).compareTo(lst_cible.getItem(u));
     if (resultat < 0) { o++; }
     else if (resultat > 0) { u++ }
     else { 
            ...
     }
}

Code en O(n.log(n)) (du fait des tris.)

[Invité]

N'hésite pas à ajouter des commentaires dans ton code.

Tu connais les librairies commons?

Elles t'apportent beaucoup notament au niveau des collections : http://commons.apache.org/collections/api/index.html