[Java] Réécrire les fonctions créées par moi-même dans le passé à partir de java.io.File avec NIO.2.

Contexte

Si vous souhaitez manipuler des fichiers et des répertoires en Java, les classes suivantes sont généralement prises en charge.

• java.io.File
• java.nio.Path
• java.nio.Files
• java.nio.file.Paths

La classe File existe depuis longtemps. NIO.2 est une classe introduite dans Java 7 et est plus récente que la classe File.

Donc, si vous souhaitez l'implémenter récemment, j'aimerais utiliser NIO.2.

Cette fois, je présenterai le code que j'ai écrit dans java.io.File et réécrit dans NIO.2.

Fonctions à introduire

• Le fichier existe-t-il dans le répertoire spécifié? --Supprimer tous les répertoires spécifiés, y compris le contenu

Le fichier existe-t-il dans le répertoire spécifié?

java 6 ou version antérieure

import java.io.File;

public class Demo {
    public static void main(String[] args) {
        File file = new File("C:/temp/");

        //Obtenez une liste de noms de fichiers et vérifiez leur existence
        if (file.listFiles().length == 0) {
            System.out.println("Il n'y a pas de dossier.");
        } else {
            System.out.println("Il y a un dossier.");
        }
    }
}

La valeur de retour de File.listFiles () est renvoyée sous la forme d'un tableau de type File. C'est un flux à juger en regardant la longueur de la séquence avec cette longueur.

java 7 ou version ultérieure

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class Demo {
    public static void main(String[] args) {
        Path path = Paths.get("C:/temp/");

        try {
            if (Files.list(path).findAny().isPresent()) {
                System.out.println("Il y a un dossier.");
            } else {
                System.out.println("Il n'y a pas de dossier.");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Files.list récupère les entrées du répertoire et les renvoie dans Strem.

```findany()```Renvoie le premier élément trouvé facultativement.
```ispresent()```Renvoie false si facultatif contient une valeur nulle, true si elle n'est pas nulle.

# Supprimer tous les répertoires spécifiés, y compris le contenu

## java 6 ou version antérieure

```java
import java.io.File;

public class Demo {
    public static void main(String[] args) {
        File dir = new File("C:/temp/");
        deleteDir(dir);
    }

    public static void deleteDir(File dir) {
        if (dir.exists() && dir.isDirectory()) {
            for (File child : dir.listFiles()) {
                if (child.isDirectory()) {
                    deleteDir(child);
                } else {
                    child.delete();
                }
            }
        }
        dir.delete();
    }
}

java 8 ou version ultérieure

**Mise en garde! ** Puisque j'utilise Stream, cela ne fonctionne qu'avec java8 ou version ultérieure.

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Comparator;

public class Demo {
    public static void main(String[] args) {
        Path path = Paths.get("C:/temp/");

        //Supprimer tous les répertoires
        try {
            Files.walk(path).sorted(Comparator.reverseOrder()).map(Path::toFile).forEach(File::delete);
            path.toFile();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Files.walk(path)Ainsi, IOException peut se produire, alors veuillez lancer ou attraper.

#### **`Files.walk(path)Obtient une liste contenant des sous-répertoires.`**
```walk(path)Obtient une liste contenant des sous-répertoires.


#### **`sorted(Comparator.reverseOrder())Trie par ordre décroissant.`**
```reverseOrder())Trie par ordre décroissant.

 Cela amènera les fichiers vers le haut et triera les répertoires vers l'arrière.
 Ensuite, le type Paths extrait par filtrage est converti en type Files et supprimé dans une boucle.
 (Je suis désolé. Je ne pourrai peut-être pas bien l'expliquer.)

 Vous pouvez convertir `` Stream <Path> '' en `` List <Path> '' en procédant comme suit.

#### **`.collect(Collectors.toList())Il suffit d'ajouter ...`**

List<Path> list = Files.walk(path).sorted(Comparator.reverseOrder()).collect(Collectors.toList());
for (Path p : list) {
    System.out.println(p);
}

prime

C'est une fonction qui est arrivée après essais et erreurs. Je vais le présenter parce que c'est beaucoup.

Supprimer les fichiers dans le répertoire spécifié

java 8 ou version ultérieure

**Mise en garde! ** Puisque j'utilise Stream, cela ne fonctionne qu'avec java8 ou version ultérieure.

import java.io.File;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class Demo {
    public static void main(String[] args) {
        Path path = Paths.get("C:/temp/");

        //Supprimer les fichiers du répertoire(Ne supprimez pas les sous-répertoires)
        try {
            Files.walk(path).filter(Files::isRegularFile).map(Path::toFile).forEach(File::delete);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

.filter(Files::isRegularFile)Donc, je vérifie si c'est un fichier normal.

 Cela exclura le répertoire de la suppression.

# finalement

 Je suis encore nouveau dans les expressions lambda Java 8, les flux, les options facultatives, etc.
 Le sentiment d'être dépassé est incroyable, alors je veux faire quelque chose à ce sujet. Mais plus je lève les yeux, moins je comprends et je suis accro au marais ...