Comment utiliser les fonctions FileInputStream et FileOutputStream en Java pour les opérations de streaming de fichiers

Les fonctions FileInputStream et FileOutputStream en Java sont deux classes importantes utilisées pour les opérations de flux de fichiers. Ils peuvent lire et écrire des fichiers et prendre en charge des opérations telles que copier, renommer et supprimer des fichiers. Cet article présentera en détail comment utiliser ces deux classes pour les opérations de flux de fichiers.

1. Classe FileInputStream

La classe FileInputStream est utilisée pour lire le contenu du fichier. Vous pouvez créer un objet de flux d'entrée de fichier via son constructeur, puis utiliser sa méthode read() pour lire le contenu du fichier octet par octet.

Voici un exemple de code pour lire le contenu du fichier à l'aide de FileInputStream :

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

public class FileInputDemo {
    public static void main(String[] args) {
        try {
            // 创建文件输入流对象
            FileInputStream fis = new FileInputStream("test.txt");

            // 读取文件内容
            int data;
            while ((data = fis.read()) != -1) {
                System.out.print((char) data);
            }

            // 关闭输入流
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Dans l'exemple de code ci-dessus, un objet FileInputStream est d'abord créé pour lire le fichier nommé test.txt, puis une boucle while est utilisée pour le lire. contenu du fichier octet par octet et imprimez-le sur la console. Enfin, fermez le flux d’entrée pour libérer les ressources.

2. Classe FileOutputStream

La classe FileOutputStream est utilisée pour écrire le contenu d'un fichier. Vous pouvez créer un objet de flux de sortie de fichier via son constructeur, puis utiliser sa méthode write() pour écrire le contenu du fichier octet par octet.

Ce qui suit est un exemple de code pour écrire le contenu d'un fichier à l'aide de FileOutputStream :

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

public class FileOutputDemo {
    public static void main(String[] args) {
        try {
            // 创建文件输出流对象
            FileOutputStream fos = new FileOutputStream("test.txt");

            // 写入文件内容
            String content = "Hello, world!";
            byte[] data = content.getBytes();
            fos.write(data);

            // 关闭输出流
            fos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Dans l'exemple de code ci-dessus, un objet FileOutputStream est d'abord créé pour écrire dans un fichier nommé test.txt, puis la chaîne "Bonjour tout le monde !" Convertissez-le en tableau d'octets et écrivez-le dans un fichier à l'aide de la méthode write(). Enfin, fermez le flux de sortie pour libérer les ressources.

3. Copier des fichiers

L'utilisation de l'opération de flux de fichiers de Java peut facilement copier des fichiers. Il vous suffit de créer deux objets de flux de fichiers, un pour lire le contenu du fichier d'origine et un pour écrire le contenu du fichier cible.

Voici un exemple de code pour copier un fichier :

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

public class FileCopyDemo {
    public static void main(String[] args) {
        try {
            // 创建文件输入流对象
            FileInputStream fis = new FileInputStream("original.txt");

            // 创建文件输出流对象
            FileOutputStream fos = new FileOutputStream("copy.txt");

            // 逐个字节读取并写入文件内容
            int data;
            while ((data = fis.read()) != -1) {
                fos.write(data);
            }

            // 关闭输入输出流
            fis.close();
            fos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Dans l'exemple de code ci-dessus, un objet FileInputStream est d'abord créé pour lire le fichier nommé original.txt, puis un objet FileOutputStream est créé pour écrire le fichier nommé copy. .txt, puis utilisez une boucle while pour lire le contenu du fichier d'origine octet par octet et l'écrire dans le fichier cible. Enfin, fermez les flux d’entrée et de sortie pour libérer les ressources.

4. Renommer des fichiers

Renommer des fichiers est l'une des fonctions couramment utilisées dans les opérations sur les fichiers. Le renommage des fichiers peut être facilement réalisé à l'aide des opérations de flux de fichiers de Java.

Ce qui suit est un exemple de code pour renommer un fichier :

import java.io.File;

public class FileRenameDemo {
    public static void main(String[] args) {
        // 创建旧文件对象
        File oldFile = new File("old.txt");

        // 创建新文件对象
        File newFile = new File("new.txt");

        // 重命名文件
        if (oldFile.renameTo(newFile)) {
            System.out.println("文件重命名成功");
        } else {
            System.out.println("文件重命名失败");
        }
    }
}

Dans l'exemple de code ci-dessus, un ancien objet fichier et un nouvel objet fichier sont d'abord créés, puis l'ancien fichier est renommé en nouveau fichier à l'aide de renameTo( ) méthode. Si le changement de nom réussit, « Renommage de fichier réussi » est affiché, sinon « Échec du renommage de fichier » est affiché.

5. Supprimer des fichiers

La suppression de fichiers est également une fonction courante d'opération de fichier. La suppression de fichiers peut être facilement réalisée à l'aide des opérations de flux de fichiers de Java.

Ce qui suit est un exemple de code pour supprimer un fichier :

import java.io.File;

public class FileDeleteDemo {
    public static void main(String[] args) {
        // 创建文件对象
        File file = new File("test.txt");

        // 删除文件
        if (file.delete()) {
            System.out.println("文件删除成功");
        } else {
            System.out.println("文件删除失败");
        }
    }
}

Dans l'exemple de code ci-dessus, un objet fichier est d'abord créé, puis le fichier est supprimé à l'aide de la méthode delete(). Si la suppression réussit, "File Deletion Successful" est affiché, sinon "File Deletion Failed" est affiché.

Résumé

Les opérations de flux de fichiers de Java sont très puissantes et flexibles. Les classes FileInputStream et FileOutputStream peuvent être utilisées pour effectuer facilement des opérations de lecture et d'écriture de fichiers, et la classe File peut être utilisée pour copier, renommer et supprimer des fichiers. Ces opérations sont essentielles pour les développeurs Java. J'espère que cet article pourra être utile aux débutants.

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!