Gestion des fichiers en Java

La gestion des fichiers fait référence à l'utilisation du fichier en Java. La lecture de fichiers et l'écriture dans des fichiers Java sont appelées gestion de fichiers en Java. Le FIle est un conteneur pouvant contenir différents types d’informations. Le fichier peut contenir du texte, des images, des vidéos, des tableaux, etc.

PUBLICITÉ Cours populaire dans cette catégorie MAÎTRISÉE JAVA - Spécialisation | 78 séries de cours | 15 tests simulés

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

En Java, la classe File nous permet de travailler avec différents types de fichiers. La classe File est membre des packages java.io. Java fournit diverses méthodes pour lire, écrire, mettre à jour et supprimer des fichiers.

Types d'opération

Différents types d'opérations pouvant être effectuées sur un fichier sont indiqués ci-dessous :

• Créer un fichier
• Mise à jour d'un fichier
• Supprimer un fichier
• Télécharger un fichier vers un emplacement spécifique
• Ouverture du fichier
• Clôture du dossier

Syntaxe :

Pour travailler avec des fichiers dans le programme, vous devez importer le package java.io. L'importation de ce package vous fournira une classe File que vous pourrez initialiser en référençant le fichier dans le constructeur de la classe File.

//importing file class
import java.io.File;
//File name passed to the object
File fileObj = new File("file.txt");

Comment fonctionne la gestion des fichiers ?

En Java, la gestion des fichiers s'effectue par des concepts de streaming. Les opérations d'entrée/sortie sur un fichier s'effectuent via le streaming. Stream fait référence à une séquence de données.

En Java, Stream est de deux types :

• Flux de personnages : Un flux de personnages fait référence à un flux qui implique les personnages. Le traitement des données s'effectue avec le Flux de caractères dans les fichiers.
• Byte Stream : Nous appelons un flux qui transfère des données en octets un flux d'octets. Le traitement des données s'effectue avec le Stream d'octets dans les fichiers.

Méthodes de gestion des fichiers

Certaines des méthodes sont données ci-dessous pour effectuer différentes opérations en Java :

1. createNewFile() : la méthode createNewFile est utilisée pour créer un fichier vide. Il renvoie la réponse sous forme booléenne.
2. getName() : Cette méthode est utilisée pour obtenir le nom du fichier. Il renvoie la chaîne, c'est-à-dire le nom du fichier en réponse.
3. getAbsolutePath() : Il renvoie le chemin absolu du fichier. Le type de retour de cette méthode est une chaîne.
4. canRead() : Cette méthode vérifie si le fichier est lisible ou non. Il renvoie une valeur booléenne.
5. canWrite() : Cette méthode vérifie si le fichier est accessible en écriture ou non. Il renvoie une valeur booléenne.
6. delete() : Cette méthode est utilisée pour supprimer un fichier. Il renvoie une valeur booléenne.
7. exists() : Utilisez cette méthode pour vérifier si un fichier existe. Il renvoie une valeur booléenne.
8. length() : Cette méthode renvoie la taille du fichier en octets. Le type de retour de cette méthode est long.
9. list() : Cette méthode renvoie un tableau des fichiers disponibles dans le répertoire. Il renvoie un tableau de valeurs de chaîne.
10. mkdir(): Pour créer un nouveau répertoire, utilisez cette méthode. Il renvoie une valeur booléenne.

Exemples de gestion de fichiers en Java

Vous trouverez ci-dessous des exemples de gestion de fichiers en Java :

Exemple #1

Dans cet exemple, le programme utilise diverses méthodes pour obtenir des détails spécifiques. Dans cette application, différentes méthodes sont utilisées pour obtenir des informations relatives aux fichiers, telles que :

1. Récupération du chemin absolu du fichier.
2. Vérifier si le fichier est accessible en écriture ou non.
3. Vérifier si le fichier est lisible ou non.
4. Récupération du nom du fichier.
5. Récupération de la taille du fichier.
6. Obtention d'une liste des fichiers présents dans le répertoire spécifié, etc.

Code :

Importation du package io de différentes classes.

import java.io.File;
import java.io.IOException;
public class FileHandlingExample2 {
public static void main(String[] args) {
// Creating an object of a file
File fileObj = new File("D:/Programs/fileHandlingOperations.txt");
if (fileObj.exists()) {
//retrieving the path of the specified file
System.out.println("\nSpecified file path: " + fileObj.getAbsolutePath());
//checking whether the file is writable or not
System.out.println("\nIs the file Writable: " + fileObj.canWrite());
//checking whether the file is Readable or not
System.out.println("\nIs the file Readable " + fileObj.canRead());
//retrieving file name
System.out.println("\nFile name: " + fileObj.getName());
//retrieving file size
System.out.println("\nFile size (in bytes) " + fileObj.length());
File fileDirObj = new File("D:/Programs/");
String[] fileList = fileDirObj.list();
//displaying here the list of files available in the directory
for (int i = 0; i < fileList.length; i++) {
System.out.print("\n" + fileList[i]);
}
System.out.println("\n");
}
else {
System.out.println("Specified file does not exist.");
}
}
}

Sortie :

Dans l'exemple ci-dessus, nous pouvons voir comment différentes méthodes fournissent les informations nécessaires pour effectuer les différentes vérifications liées aux fichiers.

Exemple #2

Cet exemple montre comment différentes méthodes sont utilisées dans le programme pour différents types d'opérations. La méthode exist() utilisée dans le programme pour vérifier si un fichier existe ne l'est pas ; après cela, la condition if..else.. est placée.

In the If condition, it checks first whether the existing file is writable or not; if the existing file remains writable, then the code block under the if section uses the FileWriter class method to write content into the existing file.

Code:

Importing io package different classes.

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
public class FileHandlingExample {
public static void main(String[] args) {
try {
File fileObj = new File("D:/Programs/fileHandlingOperations.txt");
if(fileObj.exists()){
System.out.println("File already exists.");
if(fileObj.canWrite()){
//creating object of FileWriter class to write things on file
FileWriter fwObj = new FileWriter("D:/Programs/fileHandlingOperations.txt");
// Writes this content into the specified file
fwObj.write("It is a basic example of writing in file!");
//closing the files once writing completed
fwObj.close();
System.out.println("\nContent has been written to the file.");
}else{
System.out.println("\nFile is not in writable mode.");
}
;
}else{
if (fileObj.createNewFile()) {
System.out.println("New File created: " + fileObj.getName());
}
}
}
catch (IOException ioError) {
System.out.println("An error occurred.");
ioError.printStackTrace();
}
}
}

Output:

In the above-given example, After compilation, running the program the first time will create a file with the specified name in the program.

Running the program a second time will write the content in the existing file.

Conclusion

The article above explains what a file is, how to perform operations on it, and how file handling works. It was also demonstrated in the above section about classes & methods that can be used to work with files in java.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!