Discussion :

[scolyo]

Bonjour à tous,

D'avance toutes mes excuses si je n'emploie pas les bon termes technique, il y a bien longtemps que je n'ai pas touché à java.

J'essaie d'écrire une classe qui va lister le contenu d'un dossier ainsi que le contenu de tous ses sous-dossiers. Alors je tente un appel récursif de la classe ListingDirectory(), mais ça ne fonctionne pas:

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
40
41
 
public class TreeExplorer extends Object implements Serializable {
 
    private File Directory = null;
    private File[] list = null;
    private int countFile = 0;
    private int countDirectory = 0;
 
    public void setDirectoryPath(File Directory)
    {
        this.Directory = Directory;
    }
 
public void ListingDirectory()
   {
       if (Directory.isDirectory())
       {
           list = Directory.listFiles();
           if (list != null)
           {
               for (int i = 0; i < list.length; i++)
               {
 
                   if (list[i].isFile())
                   {
                   System.out.println(list[i]);  
                   countFile++;
                   }
 
                   if (list[i].isDirectory());
                   {
                   ListingDirectory();
                   countDirectory++;
                   }
 
               }
 
               System.out.println(countDirectory + " Directory, " + countFile + " Files.");
           }
       }
   }

Et je l'utilise comme ça dans mon main:

Code :

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

1
2
3
4
5
 
TreeExplorer TreeExplorer = new TreeExplorer();
File Directory = new File(args[1]);
TreeExplorer.setDirectoryPath(Directory);
TreeExplorer.ListingDirectory();

le soucis c'est que je n'arrive pas d'autre message d'erreur que ça:

at mydedup.TreeExplorer.ListingDirectory(TreeExplorer.java:63)

D'avance merci pour toute suggestion

[dinobogan]

Tu fais une boucle infinie. Le répertoire à analyser ne doit pas être une donnée membre mais un paramètre de ta méthode. ton appel récursif analyse toujours le même répertoire.

PS : quand tu mets une trace d'erreur, met la en entier, ça aide à la rapidité de compréhension de l'erreur.

[scolyo]

Bonjour,

Merci, je n'avais pas vu le coup de la boucle infini

Je corrige mon code, et je vous dis quoi.

Ps: Pour la trace d'erreur, désolé, mais je n'avais que ça, je n'ai pas pu récupérer le reste

[scolyo]

Bonjour à tous, je suis toujours sur mon soucis pour lister les fichiers d'un dossiers ainsi que ceux des sous-dossiers. J'ai tenté une autre approche qu'un appel récursif, car ça ne fonctionne pas bien (dans mon cas en tout cas) sous Windows et carrément pas du tout sous Linux. Voila comment je fais:

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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
public ArrayList<File> getFileArray(File Directory)
    {
        ArrayList<File> FileArray = new ArrayList<File>();
        ArrayList<File> DirArray = new ArrayList<File>();
        if (Directory.isDirectory())
        {
            File[] fileList = Directory.listFiles();
            if (fileList != null)
            {
                for (int i = 0; i < fileList.length; i++)
                {
                    if (fileList[i].isFile())
                    {
                        FileArray.add(fileList[i]);
                    }
                    if (fileList[i].isDirectory())
                    {
                        DirArray.add(fileList[i]);
                    }
                }
                System.out.println(DirArray);
                System.out.println("Fin boucle for");
                System.out.println(DirArray.isEmpty());
 
                while (DirArray.isEmpty() == false)
                {
                    File[] file = DirArray.get(0).listFiles();
                    for (int i = 0; i < file.length; i++)
                    {
                        if (file[i].isFile())
                        {
                            FileArray.add(file[i]);
                        }
                        if (fileList[i].isDirectory())
                        {
                            System.out.println("Adding " + file[i]);
                            DirArray.add(file[i]);
                            System.out.println("Deleting from DirArray " + DirArray.get(0));
                            DirArray.remove(0);
                            System.out.println("This is the new DirArray[0]: " + DirArray.get(0));
                            System.out.println(DirArray);
                            System.out.println(DirArray.isEmpty());
                        }
                    }
                }
            }
            else
            {
                System.err.println(Directory + ": Error while reading.");
                System.exit(1);
            }
        }
        return FileArray;
    }

Je créé deux ArrayList<File>. Une pour avoir la liste de fichiers, l'autre la liste des répertoires. Je fais une première passe pour commencer à les peupler:

Ensuite je créé une boucle while qui traite le premier objet de l'ArrayList qui contient la liste des répertoires. Et on refait le tri. Quand se sont des fichiers, je les balance dans l'arraylist des fichiers à la suite de ce qui existe déjà, et si ce sont des répertoires, je les mets dans l'arraylist des répertoires, toujours à la suite de ce qui exite déja. Quand c'est fait, je supprime le premier objet de l'arraylist des répertoires. Et je recommence, jusqu'a ce que l'arraylist des répertoire soit vide.

Le problème, c'est que ma boucle while ne fonctionne pas. La méthode ne fait plus rien et attend indéfiniement juste après la première boucle for si le répertoire en donné en argument contient plusieurs sous-dossier, ou alors si le répertoire ne contient qu'un seul sous-dossier, la boucle while se fait une fois, mais là pareil, ça attend indéfiniement sans rien faire.

Je sens que j'ai encore fait une boucle infini quelque part, mais je ne sait pas où.

Quelqu'un aurai-il une idée?

D'avance merci.

PS: Les multiple System.out.println() ne sont le produit que de mes tentavives de "trouvage" du problème

[dinobogan]

Reste sur la méthode récursive, c'est bien plus simple :

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
public ArrayList<File> getRecursiveFile( File dir )
{
	ArrayList<File> fichiers = new ArrayList<File>();
	internalRecursiveFile( dir, fichiers );
	return fichiers;
}
 
private void internalRecursiveFile( File dir, ArrayList<File> fichiers )
{
	if( dir.isDirectory() )
	{
		File[] liste = dir.listFiles();
		for( int i = 0 ; i < liste.length ; ++i )
		{
			internalRecursiveFile( liste[ i ], fichiers );
		}
	}
	else
	{
		fichiers.add( dir );
	}
}

[scolyo]

Salut,

Je n'avais pas vu ta réponse. Bon, j'ai trouvé mes erreurs, et il y en avait un paquet, et là, ça fonctionne, en gérant les erreurs de lecture ou d'ouverture de fichiers/répertoires, et tout ça sans faire de récursif (je comprend mieux comme ça):

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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
public ArrayList<File> getFileArray(File Directory)
    {
        countFile = 0;
        countDirectory = 0;
        ArrayList<File> FileArray = new ArrayList<File>();
        ArrayList<File> DirArray = new ArrayList<File>();
        if (Directory.isDirectory())
        {
            File[] fileList = Directory.listFiles();
            if (fileList != null)
            {
                for (int i = 0; i < fileList.length; i++)
                {
                    if (fileList[i].isFile())
                    {
                        FileArray.add(fileList[i]);
                        countFile++;
                    }
                    if (fileList[i].isDirectory())
                    {
                        DirArray.add(fileList[i]);
                        countDirectory++;
                    }
                }
 
                while (DirArray.size() != 0)
                {
                    System.out.println("Processing " + DirArray.get(0));
                    File[] listDirectory = DirArray.get(0).listFiles();
                    if (listDirectory != null)
                    {
                    for (int i = 0; i < listDirectory.length; i++)
                    {
                        if (listDirectory[i].isFile())
                        {
                           FileArray.add(listDirectory[i]);
                           countFile++;
                        }
 
                        if (listDirectory[i].isDirectory())
                        {
                            DirArray.add(listDirectory[i]);
                            countDirectory++;
                        }
 
                    }
                    DirArray.remove(0);
 
                    }
                    else
                    {
                      System.err.println("-Error while reading: " + DirArray.get(0));
                      DirArray.remove(0);
                    }
                }
 
            }
            else
            {
                System.err.println("-Error while reading: " + Directory);
                System.exit(1);
            }
 
        }
        return FileArray;
 
    }

Evidemment, c'est totalement libre d'utilisation

@++