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.
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.
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).
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.
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.
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.
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.
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");
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);
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);
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
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.
-------- | 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
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.
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.
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.
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.
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数据压缩方式的编程方法。
利用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());
}
}
}
}执行结果：
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!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
