Écriture de fichiers en Java (avec exemples)
La fonction createNewFile() en Java peut créer un fichier. Cette méthode produit une valeur booléenne :true si le fichier a été complété avec succès, false s'il existe déjà. Comme vous pouvez le voir, la procédure est enfermée dans un bloc try…catch. Il est requis car une exception IOException est levée si une erreur se produit. Par exemple, si le fichier ne peut pas être créé pour une raison quelconque.
import java.io.File;
import java.io.IOException;
public class CreateFile {
public static void main(String[] args) {
try {
File newObj = new File("codeunderscored.txt");
if (newObj .createNewFile()) {
System.out.println("File created: " + newObj.getName());
} else {
System.out.println("File already exists.");
}
} catch (IOException e) {
System.out.println("An error occurred.");
e.printStackTrace();
}
}
} Pour créer un fichier dans un répertoire particulier (ce qui nécessite une autorisation), spécifiez le chemin du fichier et échappez le caractère "\" avec des doubles barres obliques inverses (pour Windows). Sur Mac et Linux, saisissez la route, par exemple /Users/name/codeunderscored .txt.
import java.io.File;
import java.io.IOException;
public class CreateFileDir {
public static void main(String[] args) {
try {
File newObj = new File("Users/Code\\codeunderscored.txt");
if (newObj .createNewFile()) {
System.out.println(" Created file: " + newObj.getName());
System.out.println("Absolute path: " + newObj.getAbsolutePath());
} else {
System.out.println("File is already there.");
}
} catch (IOException e) {
System.out.println("An error occurred.");
e.printStackTrace();
}
}
} Comment écrire dans un fichier
La classe FileWriter et sa méthode write() sont utilisées dans l'exemple suivant pour écrire du texte dans le fichier que nous avons créé précédemment. Il est important de se rappeler qu'une fois que vous avez fini d'écrire dans le fichier, vous devez le fermer avec la méthode close() :
import java.io.FileWriter;
import java.io.IOException;
public class WriteToFile {
public static void main(String[] args) {
try {
FileWriter newWriter = new FileWriter("codeunderscored .txt");
newWriter.write("Writing to files in Java is easy peasy!");
newWriter.close();
System.out.println("Completed writing to the file.");
} catch (IOException e) {
System.out.println("An error occurred.");
e.printStackTrace();
}
}
} Utilisation de la classe BufferedWriter
BufferedWriter est une classe qui vous permet d'écrire du texte tamponné. Il est utilisé pour créer un flux de sortie de caractères à partir du texte. Les caractères, les chaînes et les tableaux peuvent tous être écrits avec. Il a une taille de tampon par défaut ; cependant, il peut être changé en une taille de tampon énorme. Si aucune sortie d'invite n'est requise, il est préférable d'encapsuler cette classe avec n'importe quelle classe d'écriture pour écrire des données dans un fichier.
// Program for writing into a File using BufferedWriter Class
// Importing java input output libraries
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
// Main class
public class BufferedWriterClass {
public static void main(String[] args)
{
// Assigning the file content as input to illustrate
String text = "Welcome to Codeunderscored ";
// Try block to check for exceptions
try {
// Create a BufferedWriter object
BufferedWriter bfWriter
= new BufferedWriter(new FileWriter(
"/Users/Code/Desktop/underscored.docx"));
// Writing text to the file
bfWriter.write(text);
// Printing file contents
System.out.print(text);
// Display message showcasing program execution success
System.out.print(
"content added to file successfully");
// Closing the BufferedWriter object
bfWriter.close();
}
// Catch block for handling exceptions that occur
catch (IOException e) {
// Printing the exception message on the console
System.out.print(e.getMessage());
}
}
} Utilisation de la classe FileOutputStream
La classe BufferedWriter est utilisée pour écrire dans un fichier dans cet exemple. Cependant, comme cette classe a une grande taille de tampon, elle peut écrire d'énormes quantités de données dans le fichier. Cela nécessite également la création d'un objet BufferedWriter, tel que FileWriter, pour écrire du contenu dans le fichier.
Il est utilisé pour enregistrer les données de flux non traitées dans un fichier. Seul du texte peut être écrit dans un fichier à l'aide des classes FileWriter et BufferedWriter, mais des données binaires peuvent être écrites à l'aide de la classe FileOutputStream.
L'exemple suivant montre comment utiliser la classe FileOutputStream pour écrire des données dans un fichier. Cela nécessite également la création d'un objet de classe avec le nom de fichier pour écrire des données dans un fichier. Le contenu de la chaîne est transformé en un tableau d'octets, qui est ensuite écrit dans le fichier à l'aide de la méthode write().
// Program for Writing to a File using the FileOutputStream Class
import java.io.FileOutputStream;
import java.io.IOException;
public class WriteUsingFileOutputStream {
public static void main(String[] args)
{
// Assigning the file contents
String fileContent = "Codeunderscored extravaganza ";
FileOutputStream outputStream = null;
// Try block to check if exception occurs
try {
// Creating an object of the FileOutputStream
outputStream = new FileOutputStream("underscored.txt");
// Storing byte contents from the string
byte[] strToBytes = fileContent.getBytes();
// Writing directly into the given file
outputStream.write(strToBytes);
// Printing the success message is optional
System.out.print(
"Content added to File successfully.");
}
// Catch block handling the exceptions
catch (IOException e) {
// Showing the exception/s
System.out.print(e.getMessage());
}
// use of the finally keyword with the try-catch block – to execute irregardless of the // exception
finally {
// object closure
if (outputStream != null) {
// Second try catch block enforces file closure
// even if an error happens
try {
// file connections closure
// when no exception has happen
outputStream.close();
}
catch (IOException e) {
// shows exceptions that are encountered
System.out.print(e.getMessage());
}
}
}
}
} La fonction writeString()
La version 11 de Java prend en charge cette approche. Quatre paramètres peuvent être passés à cette méthode. L'emplacement du fichier, la séquence de caractères, le jeu de caractères et les options sont tous ces éléments. Les deux premiers paramètres sont requis pour que cette méthode écrive dans un fichier. Il enregistre les caractères en tant que contenu du fichier. Il renvoie le chemin d'accès au fichier et peut lever quatre types d'exceptions différents. Lorsque le contenu du fichier est court, il est préférable de l'utiliser.
Il montre comment placer des données dans un fichier à l'aide de la fonction writeString() de la classe Files. Une autre classe, Path, est utilisée pour associer le nom du fichier au chemin de destination du contenu.
La fonction readString() de la classe Files lit le contenu de tout fichier existant. Le code utilise ensuite ce dernier pour s'assurer que le texte est correctement écrit dans le fichier.
// Program for Writing Into a File using the writeString() Method
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
// Main class
public class WriteStringClass {
public static void main(String[] args)
throws IOException
{
//file content assigning
String text
= "Codeunderscored extravaganza!";
// definition of the file' name
Path fileName = Path.of(
"/Users/Code/Desktop/undercored.docx");
// Writing into the file
Files.writeString(fileName, text);
// Read file contents
String fileContent = Files.readString(fileName);
// Printing the files' content
System.out.println(fileContent);
}
} Conclusion
La classe Java FileWriter est utilisée pour écrire des données orientées caractères dans un fichier. C'est une classe orientée caractères puisqu'elle est utilisée dans la gestion des fichiers Java. Il existe de nombreuses façons d'écrire dans un fichier en Java, car il existe de nombreuses classes et méthodes qui peuvent accomplir cela. Ils incluent la fonction writeString(), la classe FileWriter, la classe BufferedWriter et le FileOutputStream.
