Maison  >  Article  >  Java  >  Analyse d'exemples d'entrées et de sorties d'E/S en Java

Analyse d'exemples d'entrées et de sorties d'E/S en Java

WBOY
WBOYavant
2023-05-13 15:40:061460parcourir

    Préface

    Les données stockées dans les variables, les tableaux et les objets sont temporaires et seront perdues une fois le programme terminé. Afin de pouvoir sauvegarder définitivement les données créées, elles doivent être enregistrées dans des fichiers disque afin qu'elles puissent être utilisées dans d'autres programmes. La technologie d'E/S de Java peut enregistrer les données dans des fichiers texte, des fichiers binaires et même des fichiers compressés ZIP, répondant ainsi aux exigences de stockage permanent des données. La maîtrise de la technologie de traitement des E/S peut améliorer les capacités de traitement des données.

    1. Présentation des flux

    Un flux est un ensemble de séquences de données ordonnées Selon le type d'opération, il peut être divisé en deux types : flux d'entrée et flux de sortie. Le flux E/S (Entrée/Sortie) fournit un programme de canal qui peut être utilisé pour envoyer une séquence d'octets de la source à la destination. Bien que les flux d'E/S soient généralement associés à l'accès aux fichiers disque, la source et la destination d'un programme peuvent également être le clavier, la souris, la mémoire ou la fenêtre du moniteur.
    Java gère le mode d'entrée/sortie par flux de données. Le programme lit les données dans la source à partir du flux d'entrée pointant vers la source. La source peut être un fichier, un réseau, un package compressé ou une autre source de données.
    Le flux de sortie pointe vers la destination où les données doivent être atteintes et le programme fournit des informations à la destination en écrivant des données dans le flux de sortie.

    2. Flux d'entrée/sortie

    Le langage Java définit de nombreuses classes qui sont spécifiquement responsables de diverses formes d'entrée/sortie. Ces classes sont placées dans le package java.io. Parmi eux, toutes les classes de flux d'entrée sont des sous-classes de la classe abstraite InputStream (flux d'entrée d'octets) ou de la classe abstraite Reader (flux d'entrée de caractères) et tous les flux de sortie sont une classe abstraite OutputStream (flux de sortie d'octets) ou une classe abstraite Writer (une sous-classe de caractères) ; flux de sortie).

    1. Flux d'entrée

    La classe InputStream est une classe abstraite de flux d'entrée d'octets et la classe parent de tous les flux d'entrée d'octets. La hiérarchie spécifique de la classe InputStream est la suivante.
    Toutes les méthodes de cette classe lanceront IOException lorsqu'elles rencontreront une erreur. Vous trouverez ci-dessous une brève description de certaines des méthodes de cette classe.

    Méthode read() : lit l'octet de données suivant du flux d'entrée. Renvoie une valeur d'octet entier comprise entre 0 et 255. Si aucun octet n'est disponible car la fin du flux a été atteinte, la valeur de retour est -1.
    read(byte[] b) : lit une certaine longueur d'octets à partir du flux d'entrée et renvoie le nombre d'octets sous la forme d'un entier.
    Méthode mark(int readlimit) : placez une marque à la position actuelle du flux d'entrée. Le paramètre readlimit indique à ce flux d'entrée le nombre d'octets autorisés à être lus avant l'expiration de la position de la marque. Méthode
    reset() : renvoie le pointeur d'entrée sur la marque actuelle. Méthode
    skip(long n) : saute n octets sur le flux d'entrée et renvoie le nombre réel d'octets ignorés.
    Méthode markSupported() : renvoie vrai si le flux actuel prend en charge les opérations mark()/reset().
    Méthode close : ferme ce flux d'entrée et libère toutes les ressources système associées au flux.

    Les caractères en Java sont codés en Unicode et sont codés sur deux octets. InputStream est utilisé pour traiter les octets et ne convient pas au traitement du texte de caractères. Java fournit un ensemble distinct de classes Reader pour la saisie de texte de caractères. Cependant, la classe Reader ne remplace pas la classe InputStream. Elle simplifie uniquement la programmation lors du traitement des chaînes. La classe Reader est une classe abstraite de flux d'entrée de caractères, et toutes les implémentations de flux d'entrée de caractères sont ses sous-classes.

    Les méthodes de la classe Reader sont similaires à celles de la classe InputStream. Les lecteurs peuvent consulter la documentation du JDK en cas de besoin.

    2. Flux de sortie

    La classe OutputStream est une classe abstraite de flux de sortie d'octets. Cette classe abstraite est la super classe de toutes les classes qui représentent les flux d'octets de sortie.
    Toutes les méthodes de la classe OutputStream renvoient void et une IoException est levée lorsqu'une erreur est rencontrée. Ce qui suit est une brève introduction aux méthodes de la classe OutputStream.

    Méthode write(int b) : écrivez les octets spécifiés dans ce flux de sortie. Méthode
    write(byte[] b) : écrivez b octets du tableau d'octets spécifié dans ce flux de sortie. Méthode
    write(byte[] b,int off, int len) : écrivez len octets à partir de offset off dans le tableau d'octets spécifié dans ce flux de sortie.
    Méthode Flush() : complétez complètement la sortie et videz la zone de cache.
    Méthode close() : ferme le flux de sortie.

    3. Classe File

    La classe File est le seul objet du package java.io qui représente le fichier disque lui-même. La classe File définit certaines méthodes indépendantes de la plate-forme pour gérer les fichiers. Vous pouvez créer, supprimer, renommer des fichiers et d'autres opérations en appelant des méthodes dans la classe File. Les objets de la classe File sont principalement utilisés pour obtenir certaines informations sur le fichier lui-même, telles que le répertoire où se trouve le fichier, la longueur du fichier, les autorisations de lecture et d'écriture du fichier, etc. Les flux de données peuvent écrire des données dans des fichiers, et les fichiers sont également le support de données le plus couramment utilisé pour les flux de données.

    1. Création et suppression de fichiers

    Vous pouvez utiliser la classe File pour créer un objet fichier. Les 3 méthodes de construction suivantes sont généralement utilisées pour créer des objets fichier.

    1. File(String pathname)

    Ce constructeur crée une nouvelle instance de File en convertissant la chaîne de chemin donnée en un chemin abstrait.

    La syntaxe est la suivante :

    new File(String pathname);

    Parmi eux, pathname spécifie le nom du chemin (y compris le nom du fichier). Par exemple :

    File file = new File("d:/1.txt");

    2. File (String parent,String child)

    Ce constructeur crée un nouvel objet File basé sur le chemin parent défini et les chaînes de chemin enfant (y compris les noms de fichiers).

    La syntaxe est la suivante :

    nouveau fichier (String parent,String child);

    3. File(File f,String child)

    Cette méthode de construction crée un nouveau fichier basé sur le nom du chemin abstrait Parent. et la chaîne du nom du chemin enfant.

    La syntaxe est la suivante :

    new File(File f,String child);

    2. Obtenir des informations sur le fichier

    La classe File fournit de nombreuses méthodes pour obtenir des informations sur le fichier lui-même. Comme indiqué dans le tableau suivant

    Méthode | Valeur de retour | Description
    -------- | Déterminer si le fichier est lisible
    canWrite()| boolean | Déterminer si le fichier peut être écrit
    exits()|boolean | Déterminer si le fichier existe
    length()|long | Obtenir la longueur du fichier (en octets)
    getAbsolutePath() | String | Récupère le chemin absolu du fichier
    getParent() | Récupère le chemin parent du fichier
    isFile() | Détermine si le fichier existe
    isDirectory() | est un répertoire
    isHidden() | booléen | Déterminer si le fichier est un fichier caché
    lastModified() | Obtenir l'heure de la dernière modification du fichier

    4. programme, la plupart des données sont exploitées dans la mémoire lorsque le programme se termine ou est fermé, ces données disparaîtront. Si vous devez enregistrer les données de manière permanente, vous pouvez utiliser le flux d'entrée/sortie du fichier pour établir une connexion avec le fichier spécifié et enregistrer les données requises dans le fichier de manière permanente.

    1. Classes FillInputStream et FileOutputStream

    La classe FileInputStream et la classe FileOUTputStream sont toutes deux utilisées pour faire fonctionner les fichiers disque. Si les besoins de lecture de fichiers de l'utilisateur sont relativement simples, vous pouvez utiliser la classe FileInputString, qui hérite de la classe InputString. La classe FileOutputStream correspond à la classe FileInputStream et fournit des fonctionnalités de base d'écriture de fichiers. La classe FileOutputStream est une sous-classe de la classe OutputStream.

    Les méthodes de construction couramment utilisées de la classe FileInputStream sont les suivantes :

    Classes FileInputStream(String name)
    FileInputStream(File file)

    2. Classes FileReader et FileWriter

    Utilisez la classe FileOutputStream pour écrire des données dans un fichier et utiliser la classe FileInputStream pour lire les données d'un fichier. Il existe un inconvénient dans la lecture du contenu, c'est-à-dire que les deux classes fournissent uniquement des méthodes pour lire des octets ou des tableaux d'octets. Puisque Hanzi occupe deux octets dans le fichier, si vous utilisez un flux d'octets, des caractères tronqués peuvent apparaître si la lecture n'est pas bonne. Dans ce cas, l'utilisation de la classe Reader ou Writer du flux de caractères peut éviter ce phénomène.

    Les flux de caractères FileReader et FileWriter correspondent aux classes FileInputStream et FileOutputStream. Le flux FileReader lit le fichier de manière séquentielle Tant que le flux n'est pas fermé, chaque appel à la méthode read() lit séquentiellement le reste du contenu source jusqu'à la fin de la source ou jusqu'à la fermeture du flux.

    5. Flux d'entrée/sortie avec cache

    Le cache est une optimisation des performances des E/S. Les flux de cache ajoutent une zone de cache mémoire aux flux d'E/S. Avec la zone buffer, il est possible d'exécuter les méthodes skip(), mark() et reset() sur le flux.

    1. Classes BufferedInputStream et BufferedOutputStream

    La classe BufferedInputStream peut envelopper toutes les classes InputStream avec des tampons pour optimiser les performances. La classe BufferedInputStream a deux méthodes de construction :

    BufferedInputStream(InputStream in)

    BufferedInputStream(InputStream in, int size)

    La première méthode de construction crée une zone tampon de 32 octets, et la deuxième méthode de construction commence par Create un tampon de la taille spécifiée.

    2. Classes BufferedReader et BufferedWriter

    La classe BufferedReader et la classe BufferedWriter héritent respectivement de la classe Reader et de la classe Writer. Les deux classes disposent également de mécanismes de mise en cache internes et peuvent effectuer des entrées/sorties en unités de lignes.

    6. Flux d'entrée/sortie de données

    Les flux d'entrée/sortie de données (classe DataInputStream et classe DataOutputStream) permettent aux applications de lire les types de données Java de base à partir du flux d'entrée sous-jacent de manière indépendante de la machine. En d’autres termes, lors de la lecture d’une donnée, vous n’avez plus à vous soucier du type d’octet que doit contenir la valeur.

    7. Flux d'entrée/sortie de compression ZIP

    Le fichier de gestion de compression ZIP (archive ZIP) est une forme très typique de compression de fichier, qui peut économiser de l'espace de stockage. Concernant l'implémentation des E/S de la compression ZIP, les classes intégrées de Java fournissent des classes associées très utiles, donc son implémentation est très simple. Cette section présentera l'utilisation des classes ZipOutputStream et ZipInputStream dans le package java.util.zip pour réaliser la compression/décompression de fichiers. Si vous souhaitez lire un fichier à partir d'un fichier de gestion compressé ZIP, vous devez d'abord trouver le "point d'entrée du répertoire" du fichier correspondant (à partir duquel vous pouvez connaître l'emplacement du fichier dans le fichier ZIP) avant de pouvoir lire le contenu. du dossier. Si vous souhaitez écrire le contenu du fichier dans un fichier ZIP, vous devez d'abord écrire le "point d'entrée du répertoire" correspondant au fichier, et déplacer l'emplacement où le contenu du fichier doit être écrit vers l'emplacement pointé par ce point d'entrée, puis écrivez le contenu du fichier.

    Java实现了I/O数据流与网络数据流的单一接口,因此数据的压缩、网络传输和解压缩的实现比较容易。ZipEntry类产生的对象,是用来代表一个ZIP压缩文件内的进入点(entry)。ZipInputStream用来写出ZIP压缩格式的文件,所支持的包括已压缩及未压缩的进入点(entry)。

    ZipOutputStream类用来写出ZIp压缩格式的文件,而且所支持的包括已压缩及未压缩的进入点(entry)。下面介绍利用ZipEntry、

    ZipInputStream和ZipOutputStream3个Java类实现ZIP数据压缩方式的编程方法。

    1、压缩文件

    利用ZipOutputStream类对象,可将文件压缩为.zip文件。ZipOutputStream类的构造方法如下:

    ZipOutputStram(OutputStream out);

    ZipOutputStream类的常用方法如表所示:

    方法 返回值 说明
    putNextEntry(ZipEntry e) void 开始写一个新的ZipEntry,并将流内的位置移至此entry所指数据的开头
    write(byte[] b,int off,int len) void 将字节数组写入当前ZIP条目数据
    finish() void 完成写入ZIP输出流的内容,无须关闭它所配合的OutputStream
    setComment(String comment) void 可设置此ZIP文件的注释文字

    2、解压缩ZIP文件

    ZipInputStream类可读取ZIP压缩格式的文件,包括已压缩和未压缩的条目(entry)。ZipInputStream类的构造方法如下:

    ZipInputStream(InputStream in)

    ZipInputStream类的常用方法如下表所示:

    方法 返回值 说明
    read(byte[] b, int off , int len) int 读取目标b数组内off偏移量的位置,长度是len字节
    available() int 判断是否已读完目前entry所指定的数据。已读完返回0,否则返回1
    closeEntry() void 关闭当前ZIP条目并定位流以读取下一个条目
    skip(long n) long 跳过当前ZIP条目中指定的字节数
    getNextEntry() ZipEntry 读取下一个ZipEntry,并将流内的位置移至该entry所指数据的开头
    createZipEntry(String name) ZipEntry 以指定的name参数新建一个ZipEntry对象

    补充:获取目录下的所有目录和文件

    示例:假设目录“D:\TestDir1”下有两个文件夹(dir1 和 dir2)和一个文件 file1.txt 。

    File[] listFiles()方法:获取该目录下的所有子目录和文件,返回File类数组。

    import java.io.File;
     
    /**
     * 获取目录下的所有目录和文件
     * @author pan_junbiao
     **/
    public class DirFileTest
    {
        public static void main(String[] args)
        {
            File file = new File("D:\\TestDir1");
     
            //判断目录是否存在
            if (!file.exists())
            {
                System.out.println("目录不存在");
                return;
            }
     
            //获取文件数组
            File[] fileList = file.listFiles();
            for (int i = 0; i < fileList.length; i++)
            {
                //判断是否为目录
                if (fileList[i].isDirectory())
                {
                    System.out.println("目录:" + fileList[i].getName());
                }
                else
                {
                    System.out.println("文件:" + fileList[i].getName());
                }
            }
        }
    }

    执行结果:

    Analyse dexemples dentrées et de sorties dE/S en 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!

    Déclaration:
    Cet article est reproduit dans:. en cas de violation, veuillez contacter admin@php.cn Supprimer