File Handling in Java: A Comprehensive Guide-javaTutorial-php.cn

File Handling in Java: A Comprehensive Guide

Présentation

La gestion des fichiers est une partie cruciale de tout langage de programmation. En Java, les packages java.io et java.nio fournissent des classes puissantes pour lire et écrire des fichiers, à la fois texte et binaire. Ce guide couvre l'essentiel de la gestion des fichiers en Java, y compris des exemples, des défis et des conseils pour vous aider à maîtriser ce sujet.

1. Lire et écrire des fichiers texte

Lecture de fichiers texte

Java propose plusieurs façons de lire des fichiers texte, mais la méthode la plus courante et la plus simple consiste à utiliser BufferedReader et FileReader.

Exemple :

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class TextFileReader {
    public static void main(String[] args) {
        try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Copy after login

Points clés :

BufferedReader lit le texte efficacement, ligne par ligne.
L'instruction try-with-resources garantit que les ressources sont fermées automatiquement.

Écrire des fichiers texte

Écrire dans un fichier texte est tout aussi simple avec BufferedWriter et FileWriter.

Exemple :

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class TextFileWriter {
    public static void main(String[] args) {
        try (BufferedWriter writer = new BufferedWriter(new FileWriter("example.txt"))) {
            writer.write("Hello, World!");
            writer.newLine();
            writer.write("This is a text file.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Copy after login

Défi : Écrire un programme Java qui lit un fichier texte ligne par ligne et compte le nombre de mots dans le fichier.

2. Lecture et écriture de fichiers binaires

Les fichiers binaires nécessitent une approche différente car ils ne sont pas lisibles par l'homme. Les classes FileInputStream et FileOutputStream de Java sont idéales pour lire et écrire des données binaires.

Lecture de fichiers binaires

Exemple :

import java.io.FileInputStream;
import java.io.IOException;

public class BinaryFileReader {
    public static void main(String[] args) {
        try (FileInputStream inputStream = new FileInputStream("example.dat")) {
            int byteData;
            while ((byteData = inputStream.read()) != -1) {
                System.out.print(byteData + " ");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Copy after login

Points clés :

FileInputStream lit les octets de données un par un.
Utile pour les fichiers comme des images ou des objets sérialisés.

Écrire des fichiers binaires

Exemple :

import java.io.FileOutputStream;
import java.io.IOException;

public class BinaryFileWriter {
    public static void main(String[] args) {
        try (FileOutputStream outputStream = new FileOutputStream("example.dat")) {
            outputStream.write(65); // Writes a single byte to the file
            outputStream.write(new byte[]{66, 67, 68}); // Writes multiple bytes to the file
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Copy after login

Défi : Écrire un programme qui copie un fichier binaire (comme une image) d'un emplacement à un autre.

3. Lecture à partir de fichiers ZIP

Le package java.util.zip de Java vous permet de travailler avec des fichiers ZIP. Vous pouvez extraire des fichiers d'une archive ZIP à l'aide de ZipInputStream.

Exemple :

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;

public class ZipFileReader {
    public static void main(String[] args) {
        try (ZipInputStream zipStream = new ZipInputStream(new FileInputStream("example.zip"))) {
            ZipEntry entry;
            while ((entry = zipStream.getNextEntry()) != null) {
                System.out.println("Extracting: " + entry.getName());
                FileOutputStream outputStream = new FileOutputStream(entry.getName());
                byte[] buffer = new byte[1024];
                int len;
                while ((len = zipStream.read(buffer)) > 0) {
                    outputStream.write(buffer, 0, len);
                }
                outputStream.close();
                zipStream.closeEntry();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Copy after login

Points clés :

ZipInputStream lit les entrées d'un fichier ZIP.
Chaque entrée (fichier ou répertoire) peut être extraite à l'aide de la boucle.

Défi : Écrire un programme Java qui lit tous les fichiers .txt d'une archive ZIP et imprime leur contenu sur la console.

4. Écrire dans des fichiers Office

Java ne prend pas en charge nativement l'écriture dans des fichiers Microsoft Office tels que .docx ou .xlsx, mais des bibliothèques comme Apache POI peuvent être utilisées à cette fin.

Écrire dans un fichier Excel

Exemple :

import org.apache.poi.ss.usermodel.*;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

import java.io.FileOutputStream;
import java.io.IOException;

public class ExcelFileWriter {
    public static void main(String[] args) {
        Workbook workbook = new XSSFWorkbook();
        Sheet sheet = workbook.createSheet("Sheet1");

        Row row = sheet.createRow(0);
        Cell cell = row.createCell(0);
        cell.setCellValue("Hello, Excel!");

        try (FileOutputStream outputStream = new FileOutputStream("example.xlsx")) {
            workbook.write(outputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Copy after login

Défi : Écrire un programme Java qui crée un fichier Excel avec plusieurs feuilles, chacune contenant un tableau de données.

5. Lecture et écriture de fichiers XML

Java propose plusieurs façons de travailler avec des fichiers XML. Le package javax.xml.parsers est couramment utilisé pour cela.

Lecture d'un fichier XML

Exemple :

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;

import java.io.File;

public class XMLFileReader {
    public static void main(String[] args) {
        try {
            File file = new File("example.xml");
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder();
            Document doc = builder.parse(file);

            NodeList nodeList = doc.getElementsByTagName("tagname");
            for (int i = 0; i < nodeList.getLength(); i++) {
                System.out.println(nodeList.item(i).getTextContent());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Copy after login

Écrire dans un fichier XML

Exemple :

import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.*;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

import java.io.File;

public class XMLFileWriter {
    public static void main(String[] args) {
        try {
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder();
            Document doc = builder.newDocument();

            Element root = doc.createElement("root");
            doc.appendChild(root);

            Element child = doc.createElement("child");
            child.appendChild(doc.createTextNode("Hello, XML!"));
            root.appendChild(child);

            TransformerFactory transformerFactory = TransformerFactory.newInstance();
            Transformer transformer = transformerFactory.newTransformer();
            transformer.setOutputProperty(OutputKeys.INDENT, "yes");

            DOMSource source = new DOMSource(doc);
            StreamResult result = new StreamResult(new File("example.xml"));

            transformer.transform(source, result);
        } catch (ParserConfigurationException | TransformerException e) {
            e.printStackTrace();
        }
    }
}

Copy after login

Défi : Créer un programme Java qui lit un fichier de configuration XML et affiche les paramètres dans un format lisible par l'homme.

6. Gestion des exceptions dans les E/S de fichier

Lorsque vous travaillez avec des fichiers, des exceptions sont courantes en raison de problèmes tels que des fichiers manquants, des erreurs d'autorisation ou des formats de données inattendus. Une gestion appropriée des exceptions est essentielle pour les programmes robustes.

Exceptions d'E/S courantes

FileNotFoundException : Se produit lorsque vous essayez d'ouvrir un fichier qui n'existe pas.
IOException : Une exception générale pour les échecs d'E/S, tels que les erreurs de lecture ou d'écriture.

Bonnes pratiques :

Utilisez try-with-resources : Cela garantit que les fichiers sont correctement fermés même si une exception se produit.
Blocs Catch spécifiques : Gérez différentes exceptions séparément pour fournir des messages d'erreur significatifs.
Journalisation : Enregistrez toujours les exceptions pour aider à diagnostiquer les problèmes en production.

Exemple :

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class FileExceptionHandling {
    public static void main(String[] args) {
        try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            System.err.println("An I/O error occurred: " + e.getMessage());
        }
    }
}

Copy after login

Conclusion

File handling in Java is a powerful feature, enabling you to work with various file types, from simple text files to complex XML and binary files. By mastering these techniques, you'll be well-equipped to handle any file-based tasks in your Java applications.

Final Challenge: Combine reading and writing techniques to create a program that reads data from an Excel file, processes it, and then writes the results to a new XML file.

Tips & Tricks:

Buffering: Always use buffering (BufferedReader, BufferedWriter) for large files to improve performance.
File Paths: Use Paths and Files classes from java.nio.file for more modern and flexible file handling.
UTF-8 Encoding: Always specify character encoding when dealing with text files to avoid encoding issues.

Happy coding!

The above is the detailed content of File Handling in Java: A Comprehensive Guide. For more information, please follow other related articles on the PHP Chinese website!