Comment implémenter des opérations de lecture et d'écriture de fichiers en Java

Les opérations d'entrée et de sortie de fichiers en Java sont une tâche de base. En Java, vous pouvez utiliser File et FileInputStream, FileOutputStream, BufferedReader, PrintWriter et d'autres classes pour effectuer des opérations de lecture et d'écriture de fichiers.

Lecture de fichiers

En Java, les fichiers peuvent être lus à l'aide des classes FileInputStream et BufferedReader.

FileInputStream :

FileInputStream peut être utilisé pour lire le flux d'entrée d'un fichier ouvert dans le système de fichiers. Il hérite de la classe InputStream et fournit de nombreuses méthodes liées aux E/S de fichiers. Nous pouvons l'utiliser pour ouvrir un fichier sous un chemin spécifié et lire les données du fichier.

FileInputStream inputStream = null;
try {
    File file = new File("file.txt");
    inputStream = new FileInputStream(file);
    int content;
    while ((content = inputStream.read()) != -1) {
        // 处理读取到的字节
    }
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (inputStream != null) {
        try {
            inputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Dans le code ci-dessus, nous créons d'abord un objet File, puis utilisons FileInputStream pour lire le contenu du fichier. Puisque FileInputStream ne peut lire qu'un octet à la fois, nous devons utiliser une boucle while pour lire chaque octet en continu. Lorsque la méthode read() renvoie -1, cela signifie que l'intégralité du fichier a été lu.

BufferedReader :

Un flux d'entrée de caractères mis en mémoire tampon peut être encapsulé par la classe wrapper BufferedReader pour encapsuler un flux d'entrée de caractères. Son avantage est qu'il peut lire plusieurs caractères à la fois, améliorant ainsi l'efficacité de la lecture des fichiers.

BufferedReader reader = null;
try {
    File file = new File("file.txt");
    FileReader fileReader = new FileReader(file);
    reader = new BufferedReader(fileReader);
    String content;
    while ((content = reader.readLine()) != null) {
        // 处理读取到的一行字符串
    }
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (reader != null) {
        try {
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Dans le code ci-dessus, nous créons d'abord un objet File, puis utilisons FileReader pour convertir le fichier en flux de caractères et utilisons BufferedReader pour l'envelopper. Lors de la lecture du contenu de chaque ligne, utilisez la méthode readLine(). Lorsque cette méthode renvoie null, cela signifie que l'intégralité du fichier a été lue.

Écriture de fichiers

En Java, vous pouvez utiliser les classes FileOutputStream et PrintWriter pour écrire des fichiers.

FileOutputStream :

FileOutputStream est un flux de sortie utilisé pour générer des données dans le système de fichiers. Il s'agit d'une sous-classe de la classe OutputStream et possède de nombreuses méthodes liées à l'entrée et à la sortie de fichiers. Nous pouvons l'utiliser pour ouvrir un fichier sous le chemin spécifié et écrire des données dans le fichier.

FileOutputStream outputStream = null;
try {
    File file = new File("file.txt");
    outputStream = new FileOutputStream(file);
    String content = "Hello, world!";
    byte[] bytes = content.getBytes();
    outputStream.write(bytes);
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (outputStream != null) {
        try {
            outputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Dans le code ci-dessus, nous créons d'abord un objet File, puis utilisons FileOutputStream pour écrire le contenu du fichier. Étant donné que FileOutputStream ne peut écrire qu'un seul octet ou un tableau d'octets à la fois, nous devons convertir la chaîne que nous voulons écrire en tableau d'octets.

PrintWriter :

PrintWriter est une classe wrapper qui encapsule un flux de sortie de caractères dans un flux de sortie d'impression. Il fournit des méthodes pratiques pour générer divers types de données, notamment des chaînes, des nombres, etc. De plus, PrintWriter peut également formater les données écrites.

PrintWriter writer = null;
try {
    File file = new File("file.txt");
    FileWriter fileWriter = new FileWriter(file);
    writer = new PrintWriter(fileWriter);
    String content = "Hello, world!";
    writer.println(content);
} catch (IOException e) {
    e.printStackTrace();
}

Dans le code ci-dessus, nous créons d'abord un objet File, puis utilisons FileWriter pour convertir le fichier en flux de caractères et utilisons PrintWriter pour l'envelopper. Ici, nous utilisons la fonction println() pour écrire la chaîne, qui ajoute automatiquement un caractère de nouvelle ligne à la fin de la chaîne.

Copie de fichier

En Java, vous pouvez utiliser FileInputStream et FileOutputStream pour implémenter la fonction de copie de fichier.

FileInputStream inputStream = null;
FileOutputStream outputStream = null;
try {
    File sourceFile = new File("source.txt");
    File targetFile = new File("target.txt");
    inputStream = new FileInputStream(sourceFile);
    outputStream = new FileOutputStream(targetFile);
    byte[] buffer = new byte[1024];
    int length;
    while ((length = inputStream.read(buffer)) > 0) {
        outputStream.write(buffer, 0, length);
    }
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (inputStream != null) {
        try {
            inputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    if (outputStream != null) {
        try {
            outputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Nous avons d'abord créé deux objets File dans ce code, l'un pour représenter le fichier source et l'autre pour représenter le fichier cible. Ensuite, utilisez FileInputStream et FileOutputStream pour lire le fichier d'origine et l'écrire dans le fichier cible. Un tampon (tableau d'octets) doit être utilisé pour stocker les données lues, car seule une certaine longueur de données d'octets peut être lue à la fois. Enfin, lorsque l'intégralité du fichier a été lue, les flux d'entrée et de sortie sont fermés.

Suppression de fichier

En Java, vous pouvez utiliser la méthode delete() de la classe File pour supprimer un fichier.

File file = new File("file.txt");
if (file.delete()) {
    System.out.println("文件删除成功！");
} else {
    System.out.println("文件删除失败！");
}

Nous avons utilisé un objet File pour supprimer le fichier. Nous avons d'abord créé l'objet puis appelé sa méthode delete(). Une suppression de fichier réussie renverra vrai, tandis qu'un échec de suppression de fichier renverra faux.

Renommage de fichiers

En Java, vous pouvez utiliser la méthode renameTo() de la classe File pour implémenter la fonction de renommage de fichiers.

File sourceFile = new File("source.txt");
File targetFile = new File("target.txt");
if (sourceFile.renameTo(targetFile)) {
    System.out.println("文件重命名成功！");
} else {
    System.out.println("文件重命名失败！");
}

Nous avons d'abord instancié deux objets File, l'un représente le nom du fichier d'origine et l'autre représente le nom du fichier cible. Utilisez la méthode renameTo() pour renommer le nom du fichier d'origine en nom de fichier cible. Si vrai est renvoyé, cela signifie que le changement de nom du fichier a réussi ; si faux est renvoyé, cela signifie que le changement de nom du fichier a échoué.

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!