Discussion :

[run(F) jkldc]

Bonjour,

je souhaite faire la différence de contenu entre 2 dossiers (A et B). Pour cela je souhaite utiliser les DirectoryStream ce qui me donne 2 listes de Path (une pour chaque dossier). Mon problème viens du fait que cette liste n'est pas ordonnée (un print d'une des liste me fourni un ensemble désordonné, tant en type (fichiers/sous-dossier) que lexicographiquement ).
Le problème qui en découle est le suivant:

si je veux utilise ce moyen (différence de contenu) pour faire une fonction de synchronisation l'efficacité vas êtres proche de N*M (N: longueur de la différence de contenu du dossier A, M longueur de la différence de contenu du dossier B).

et je ne suis pas certains de pouvoir parcourir plusieurs fois le même DirectoryStream.

Mon résonnement est-il faux.
Et comment m'y prendre, que ce raisonnement soit vrai ou faux ?

[PhilippeGibault]

Si à la fin tu as une liste, pourquoi ne pas l'ordonner avec un Comparator?
https://docs.oracle.com/en/java/java...omparator.html

Ensuite, tu peux:

Code :

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

1
2
 
Collections.sort(list,comparator);

https://docs.oracle.com/en/java/java...llections.html

Voir mieux, le faire dans un stream:
https://mkyong.com/java8/java-8-how-...stream-sorted/
Le stream permet en plus de classer par ordre désordonné.

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
 
@Override
	public List<Integer> simuleJet(Integer nombreDe, boolean chanceAuxDes) throws JetDeException{
		if(nombreDe < 0) {
			Object[] params = {nombreDe};
			throw new JetDeException(params, "jet.de.calcul.proba.simulation.nombre.negatif");
		}
		List<Integer> orderList = 
				chanceAuxDes?scoresPossibles.stream().sorted(Comparator.reverseOrder()).toList() 
						:scoresPossibles.stream().sorted(Comparator.naturalOrder()).toList();
		int index = 0;
		List<Integer> lReturn = new ArrayList<>();
		for(int i = 0; i < nombreDe; i++) {
			lReturn.add(orderList.get(index));
			index++;
			if(index == orderList.size()) {
				index = 0;
			}
		}
		return lReturn.stream().sorted(Comparator.reverseOrder()).toList();
	}

il est possible d'utiliser un comparator pour les stream.

De plus, Path est comparable, donc ordonnable sans comparateur:
https://docs.oracle.com/en/java/java...file/Path.html

[run(F) jkldc]

merci pour votre réponse.

Voici un bout de code:

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
 
public static void Test(String[] args) throws IOException {		
 
  Path workingDirectory; 
 
  switch (args.length) {
     case 0 -> { workingDirectory = Paths.get(System.getProperty("user.dir")); }
     case 1 -> { workingDirectory = Paths.get(args[0]); }
     default -> { return; }
  }
  try { 
       DirectoryStream<Path> directoryContent = Files.newDirectoryStream(workingDirectory);
       for (Path entry: directoryContent) {
            System.out.println(entry.getFileName());
            System.out.println(entry.getParent());
       } 
      directoryContent.close();
   }
   catch (IOException e) { System.out.println("erreur de flux"); }
}

Si on omet le fais que la méthode ne renvois rien et que le flux est fermé à la fin, ce code fourni un DirectoryStream<Path> (DSP) sur un dossier. En l'appelant sur un second dossier j'obtiendrai un second DirectoryStream<Path>.
Si ces deux DirectoryStream<Path> sont triés ( et c'est la un de mes problème, d'après quel critères ou ensemble de critères). Il possible de parcourir le premier DSP et, à chaque élément du premier DSP, je cherche une égalité sur les éléments du second DSP. En cas de concordance je les retire des deux DSP. A la fin chaque flux ne contient plus que les Path propres à chaque dossier.
Avec un iterator sur chaque le coût théorique est de N+M.
Pour les critères de comparaison, tant pour le tri de chaque DSP que pour la comparaison de leur éléments, je n'arrive pas à voir comment m'y prendre.
Car d'après la doc oracle:

boolean equals(Object other) Tests this path for equality with the given object.

mais comment ?

[PhilippeGibault]

Je ne sais pas selon quels critères sont trié un Path.

Au pire, tu peux récupérer une liste au fur et à mesure et trier à la fin.

Et si il y a un problème, tu peux toujours implémenter Comparable pour définir la façon dont tu compte trier.

[run(F) jkldc]

ok, merci je vais essayer ça.