import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.stream.Stream;
public class Explorateur {
public void Fichiers(String chemin) throws IOException {
Path disque=Paths.get(chemin);
try (Stream<Path> paths=Files.walk(disque, Integer.MAX_VALUE)) {
paths.filter(Files::isRegularFile)
.forEach(System.out::println);
} catch(IOException e) {
e.printStackTrace();
}
}
}
How can I do it without using Stream and sort it by creation date using just NIO ?At first I need to check if a specific file is there. The second function is to sort all files by creation date.I think that I should return a collection of files and creation date then sort it.
3 Réponses :
Vous venez de collecter le flux code> dans une collection comme définir code>, triété code> ou Liste code>: TreeSet<Path> paths = Files.walk(path).collect(Collectors.toCollection(TreeSet::new));
if (paths.contains(a)) {
// checked for presence
}
// if you want to sort the files right away
List<File> files = Files.walk(path)
.map(Path::toFile)
.sorted(Comparator.comparing(File::lastModified))
.collect(Collectors.toList());
Mais c'est en fait est: à l'aide d'un flux.
OP voulait utiliser une collection de fichiers puis triez-la. J'interpréte la question comme "Comment puis-je obtenir cette liste dans une structure de données autre que le flux", à laquelle la réponse est de collecter () dans laquelle la collecte correspond au mieux à vos besoins.
Cet exemple fonctionne à l'aide de plus Vous pouvez trier par nom, création, temps modifié, etc. : P> FileVisitor code>. Il est plus long que des exemples de flux, mais sera plus rapide sur les très grandes structures de répertoires tels que FileVisitor CODE> Fournit basicfileattributes afin d'éviter les appels de fichiers Io enritilement. public class ExampleFileVisitor
{
public static void main(String[] args) throws IOException
{
Path dir = Path.of(args[0]);
long start = System.currentTimeMillis();
HashMap<Path,BasicFileAttributes> pathAttrs = scan(dir);
ArrayList<Path> paths = new ArrayList<>(pathAttrs.keySet());
Collections.sort(paths, Comparator.comparing(p -> pathAttrs.get(p).lastModifiedTime()));
// Collections.sort(paths, Comparator.comparing(p -> pathAttrs.get(p).creationTime()));
// Collections.sort(paths, Comparator.comparing(Path::getFileName));
List<Path> top5 = paths.subList(0, Math.min(5, paths.size()));
long elapsed = System.currentTimeMillis() - start;
System.out.println("DONE "+dir+" SIZE "+paths.size()+" in "+elapsed+"ms");
for (Path f : top5)
System.out.println("Found "+f);
}
private static HashMap<Path, BasicFileAttributes> scan(Path dir) throws IOException
{
HashMap<Path,BasicFileAttributes> pathAttrs = new HashMap<>();
FileVisitor<Path> visitor = new FileVisitor<>() {
public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
return FileVisitResult.CONTINUE;
}
public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
pathAttrs.put(file, attrs);
return FileVisitResult.CONTINUE;
}
public FileVisitResult visitFileFailed(Path file, IOException exc) throws IOException {
throw exc;
}
public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
return FileVisitResult.CONTINUE;
}
};
//visitor = Delegate.create(visitor, FileVisitor.class);
Files.walkFileTree(dir, visitor);
return pathAttrs;
}
}
Et utilisez chemins.Contains (quoi que ce soit) ou pathattrs.get (peu importe)! = Null pour vérifier un chemin spécifique.
Merci beaucoup @Duncg pour vos efforts. Vous prenez le temps d'imprimer cette sorcière de code semble longue sans ruisseau. Mais je pense que vous devriez écrire le chemin pas var.
Ce code est pour Java 10+. Il devrait fonctionner avec Var remplacé par chemin si votre Java est plus âgée.
Changé de réponse donc pas "var". Vous pouvez simplement découvrir des lignes pour d'autres paramètres de tri.
contient uniquement du code Pre Java 8.
import java.io.IOException;
import java.nio.file.DirectoryStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.attribute.FileTime;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
public class ListFile {
private static List<Path> lst = new ArrayList<>();
private static void roam(Path path) throws IOException {
if (Files.isRegularFile(path)) {
lst.add(path);
}
else if (Files.isDirectory(path)) {
DirectoryStream<Path> ds = Files.newDirectoryStream(path); // throws java.io.IOException
Iterator<Path> iterator = ds.iterator();
while (iterator.hasNext()) {
roam(iterator.next());
}
}
}
/**
* @param args - starting directory.
*
* @throws IOException if fails to access directory.
*/
public static void main(String[] args) throws IOException {
if (args.length < 1) {
System.out.println("ARGS: <directory>");
}
else {
Path p = Paths.get(args[0]);
roam(p);
Comparator<Path> comp = new Comparator<Path>() {
@Override
public int compare(Path p1, Path p2) {
if (p1 == null) {
if (p2 == null) {
return 0;
}
else {
return 1;
}
}
else {
if (p2 == null) {
return -1;
}
else {
try {
FileTime ft1 = (FileTime) Files.getAttribute(p1, "creationTime");
FileTime ft2 = (FileTime) Files.getAttribute(p2, "creationTime");
return ft1.compareTo(ft2);
}
catch (IOException xIo) {
throw new RuntimeException(xIo);
}
}
}
}
};
Collections.sort(lst, comp);
int count = 0;
int limit = 5;
for (Path pth : lst) {
try {
FileTime ft = (FileTime) Files.getAttribute(p, "creationTime");
System.out.printf("[%s] %s%n", ft, pth);
}
catch (IOException xIo) {
throw new RuntimeException(xIo);
}
if (++count == limit) {
break;
}
}
}
}
}
C'est un bon code mais vous avez utilisé java.io.file.listfiles () que je ne peux pas utiliser .Le code doit être fait en utilisant uniquement Nio API et non io .in Nio Nous n'avons pas de fichiers.
Je vous remercie beaucoup pour votre aide
Si vous souhaitez éviter les ruisseaux (pourquoi cependant?) Vous pouvez utiliser
walkfiletree qui prend unfileceptor appelé pour chaque fichier.Je suis d'accord avec vous @ Joachim Sauer.Utilisant Stream est le meilleur moyen d'avoir un code de nettoyage.Mais mon problème est que je dois trier les fichiers par date de création et afficher uniquement les cinq premiers. Pour ce faire. Je pense que je dois mettre le résultat de ma fonction dans un hashmap en tant que clé puis mettez une date de création à l'aide de "Attribute.BasicFileAttributes" .Quelle pensez-vous? Si mon idée est bonne, comment peut-on l'appliquer?