Die in Variablen, Arrays und Objekten gespeicherten Daten sind vorübergehend vorhanden und verschwinden nach Programmende verloren . Um die erstellten Daten dauerhaft speichern zu können, müssen diese in Datenträgerdateien gespeichert werden, damit sie in anderen Programmen verwendet werden können. Die I/O-Technologie von Java kann Daten in Textdateien, Binärdateien und sogar ZIP-komprimierten Dateien speichern und erfüllt damit die Anforderungen für eine dauerhafte Datenspeicherung. Die Beherrschung der I/O-Verarbeitungstechnologie kann die Datenverarbeitungsfähigkeiten verbessern.
Ein Stream ist eine Menge geordneter Datensequenzen, die in zwei Typen unterteilt werden können: Eingabestream und Ausgabe Strom. Der I/O-Stream (Eingabe/Ausgabe) stellt ein Kanalprogramm bereit, mit dem eine Folge von Bytes von der Quelle zum Ziel gesendet werden kann. Obwohl I/O-Streams normalerweise mit dem Zugriff auf Festplattendateien verbunden sind, können Quelle und Ziel eines Programms auch die Tastatur, die Maus, der Speicher oder das Monitorfenster sein.
Java verarbeitet den Eingabe-/Ausgabemodus nach Datenstrom. Das Programm liest die Daten in der Quelle aus dem Eingabestrom, der auf die Quelle verweist. Die Quelle kann eine Datei, ein Netzwerk, ein komprimiertes Paket oder eine andere Datenquelle sein.
Der Ausgabestream zeigt auf das Ziel, an dem die Daten erreicht werden sollen, und das Programm liefert Informationen an das Ziel, indem es Daten in den Ausgabestream schreibt.
Die Java-Sprache definiert viele Klassen, die speziell für verschiedene Formen der Eingabe/Ausgabe verantwortlich sind. Solche Klassen werden im java.io-Paket platziert . Unter diesen sind alle Eingabestreamklassen Unterklassen der abstrakten Klasse InputStream (Byte-Eingabestream) oder der abstrakten Klasse Reader (Zeicheneingabestream); und alle Ausgabestreams sind die abstrakte Klasse OutputStream (Byte-Ausgabestream) oder die abstrakte Klasse Writer (Eine Unterklasse von Zeichen). Ausgabestrom).
Die InputStream-Klasse ist eine abstrakte Klasse von Byte-Eingabestreams und die übergeordnete Klasse aller Byte-Eingabestreams. Die spezifische Hierarchie der InputStream-Klasse ist wie folgt.
Alle Methoden in dieser Klasse lösen eine IOException aus, wenn ein Fehler auftritt. Nachfolgend finden Sie eine kurze Beschreibung einiger Methoden dieser Klasse.
read()-Methode: Liest das nächste Datenbyte aus dem Eingabestream. Gibt einen int-Byte-Wert im Bereich von 0 bis 255 zurück. Wenn keine Bytes verfügbar sind, weil das Ende des Streams erreicht wurde, ist der Rückgabewert -1.
read(byte[] b): Liest eine bestimmte Länge von Bytes aus dem Eingabestream und gibt die Anzahl der Bytes in Form einer Ganzzahl zurück.
mark(int readlimit)-Methode: Platzieren Sie eine Markierung an der aktuellen Position des Eingabestreams. Der Parameter readlimit teilt diesem Eingabestream mit, wie viele Bytes gelesen werden dürfen, bevor die Markierungsposition abläuft.
reset()-Methode: Gibt den Eingabezeiger auf die aktuelle Markierung zurück.
skip(long n)-Methode: Überspringen Sie n Bytes im Eingabestream und geben Sie die tatsächliche Anzahl der übersprungenen Bytes zurück.
markSupported()-Methode: Gibt true zurück, wenn der aktuelle Stream mark()/reset()-Operationen unterstützt.
close-Methode: Schließen Sie diesen Eingabestream und geben Sie alle mit dem Stream verknüpften Systemressourcen frei.
Zeichen in Java sind Unicode-codiert und sind Doppelbyte. InputStream wird zur Verarbeitung von Bytes verwendet und ist nicht für die Verarbeitung von Zeichentext geeignet. Java bietet einen separaten Satz von Reader-Klassen speziell für die Eingabe von Zeichentexten. Die Reader-Klasse ist jedoch kein Ersatz für die InputStream-Klasse. Sie vereinfacht lediglich die Programmierung bei der Verarbeitung von Zeichenfolgen. Die Reader-Klasse ist eine abstrakte Klasse von Zeicheneingabeströmen, und alle Implementierungen von Zeicheneingabeströmen sind ihre Unterklassen.
Die Methoden in der Reader-Klasse ähneln denen in der InputStream-Klasse. Leser können bei Bedarf die JDK-Dokumentation überprüfen.
Die OutputStream-Klasse ist eine abstrakte Klasse von Byte-Ausgabestreams. Diese abstrakte Klasse ist die Superklasse aller Klassen, die Ausgabebytestreams darstellen.
Alle Methoden in der OutputStream-Klasse geben void zurück und eine IoException wird ausgelöst, wenn ein Fehler auftritt. Im Folgenden finden Sie eine kurze Einführung in die Methoden in der OutputStream-Klasse.
write(int b) Methode: Schreiben Sie die angegebenen Bytes in diesen Ausgabestream.
write(byte[] b)-Methode: Schreiben Sie b Bytes aus dem angegebenen Byte-Array in diesen Ausgabestream.
write(byte[] b, int off, int len) Methode: Schreibe len Bytes beginnend mit Offset Off im angegebenen Byte-Array in diesen Ausgabestream.
flush()-Methode: Vervollständigen Sie die Ausgabe vollständig und leeren Sie den Cache-Bereich.
close()-Methode: Schließt den Ausgabestream.
Die Dateiklasse ist das einzige Objekt im java.io-Paket, das die Festplattendatei selbst darstellt. Die File-Klasse definiert einige plattformunabhängige Methoden zum Betreiben von Dateien. Sie können Dateien erstellen, löschen, umbenennen und andere Vorgänge ausführen, indem Sie Methoden in der File-Klasse aufrufen. Objekte der File-Klasse werden hauptsächlich verwendet, um einige Informationen über die Datei selbst zu erhalten, z. B. das Verzeichnis, in dem sich die Datei befindet, die Länge der Datei, Lese- und Schreibberechtigungen für die Datei usw. Datenströme können Daten in Dateien schreiben, und Dateien sind auch die am häufigsten verwendeten Datenträger für Datenströme.
Sie können die File-Klasse verwenden, um ein Dateiobjekt zu erstellen. Die folgenden drei Konstruktionsmethoden werden normalerweise zum Erstellen von Dateiobjekten verwendet.
Dieser Konstruktor erstellt eine neue Dateiinstanz, indem er die angegebene Pfadnamenzeichenfolge in einen abstrakten Pfadnamen umwandelt.
Die Syntax lautet wie folgt:
new File(String pathname);
wobei pathname den Pfad angibt Name (einschließlich Dateiname). Zum Beispiel:
Datei file = new File(“d:/1.txt”);
Dieser Konstruktor erstellt ein neues Dateiobjekt basierend auf den definierten übergeordneten Pfad- und untergeordneten Pfadzeichenfolgen (einschließlich Dateinamen).
Die Syntax lautet wie folgt:
new File(String parent,String child);
Dieser Konstruktor erstellt eine neue Dateiinstanz basierend auf dem übergeordneten abstrakten Pfadnamen und der untergeordneten Pfadnamenzeichenfolge.
Die Syntax lautet wie folgt:
new File(File f,String child);
Die File-Klasse bietet viele Methoden zum Abrufen einiger Informationen über die Datei selbst. Wie in der folgenden Tabelle gezeigt
#Methode |. -------- | String|. Holen Sie sich den Namen der DateiFileInputStream(String name)length()|long |. Holen Sie sich die Länge der Datei (in Bytes)
getAbsolutePath() | () |. String |. Ermitteln Sie, ob die Datei vorhanden ist.
isHidden( ) |. Bestimmen Sie, ob es sich bei der Datei um eine versteckte Datei handelt
4. 🎜🎜#
Während der Ausführung des Programms befinden sich die meisten Daten im Speicher. Führen Sie Vorgänge aus und diese Daten verschwinden, wenn das Programm endet oder geschlossen wird. Wenn Sie die Daten dauerhaft speichern müssen, können Sie den Datei-Eingabe-/Ausgabestream verwenden, um eine Verbindung mit der angegebenen Datei herzustellen und die erforderlichen Daten dauerhaft in der Datei zu speichern.
1. FillInputStream- und FileOutputStream-Klassen
Sowohl die FileInputStream-Klasse als auch die FileOUtputStream-Klasse werden zum Betreiben von Festplattendateien verwendet. Wenn die Dateileseanforderungen des Benutzers relativ einfach sind, können Sie die FileInputString-Klasse verwenden, die von der InputString-Klasse erbt. Die FileOutputStream-Klasse entspricht der FileInputStream-Klasse und bietet grundlegende Funktionen zum Schreiben von Dateien. Die FileOutputStream-Klasse ist eine Unterklasse der OutputStream-Klasse.
Die häufig verwendeten Konstruktionsmethoden der FileInputStream-Klasse lauten wie folgt:
2. FileReader- und FileWriter-Klassen
FileReader- und FileWriter-Zeichenströme entsprechen den FileInputStream- und FileOutputStream-Klassen. Der FileReader-Stream liest die Datei sequentiell, solange der Stream nicht geschlossen ist, liest jeder Aufruf der read()-Methode sequentiell den Rest des Quellinhalts, bis das Ende der Quelle oder des Streams geschlossen wird.
Cache ist eine Leistungsoptimierung von I/O. Cache-Streams fügen I/O-Streams einen Speicher-Cache-Bereich hinzu. Mit dem Pufferbereich ist es möglich, die Methoden „skip()“, „mark()“ und „reset()“ auf dem Stream auszuführen.
1. BufferedInputStream- und BufferedOutputStream-Klassen
BufferedInputStream(InputStream in, int size)
Eine Konstruktion Die Methode erstellt einen Puffer von 32 Bytes und die zweite Konstruktionsmethode erstellt einen Puffer der angegebenen Größe. 2. BufferedReader- und BufferedWriter-Klassen Die BufferedReader-Klasse und die BufferedWriter-Klasse erben die Reader-Klasse bzw. die Writer-Klasse. Beide Klassen verfügen außerdem über interne Caching-Mechanismen und können Ein-/Ausgaben in Zeileneinheiten durchführen. 6. Dateneingabe-/-ausgabeströmeDateneingabe-/-ausgabeströme (DataInputStream-Klasse und DataOutputStream-Klasse) ermöglichen es Anwendungen, maschinenunabhängig aus dem zugrunde liegenden Eingabestrom zu lesen Nehmen Sie grundlegende Java-Datentypen. Mit anderen Worten: Beim Lesen eines Datenelements müssen Sie sich keine Gedanken mehr darüber machen, welche Art von Byte der Wert haben soll.
7. ZIP-Komprimierungs-Eingabe-/Ausgabestream
ZIP-Komprimierungsverwaltungsdatei (ZIP-Archiv) ist eine sehr typische Form der Dateikomprimierung, die Speicherplatz sparen kann. In Bezug auf die E/A-Implementierung der ZIP-Komprimierung bieten die integrierten Klassen von Java sehr nützliche verwandte Klassen, sodass die Implementierung sehr einfach ist. In diesem Abschnitt wird die Verwendung der Klassen ZipOutputStream und ZipInputStream im Paket java.util.zip vorgestellt, um eine Dateikomprimierung/-dekomprimierung zu erreichen. Wenn Sie eine Datei aus einer ZIP-komprimierten Verwaltungsdatei lesen möchten, müssen Sie zunächst den „Verzeichniseinstiegspunkt“ der entsprechenden Datei finden (anhand dessen Sie den Speicherort der Datei in der ZIP-Datei ermitteln können), bevor Sie den Inhalt lesen können der Datei. Wenn Sie den Dateiinhalt in eine ZIP-Datei schreiben möchten, müssen Sie zuerst den der Datei entsprechenden „Verzeichniseinstiegspunkt“ schreiben und den Speicherort, an dem der Dateiinhalt geschrieben werden soll, an den Speicherort verschieben, auf den dieser Einstiegspunkt zeigt. und schreiben Sie dann den Dateiinhalt.
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());
}
}
}
}执行结果：
Das obige ist der detaillierte Inhalt vonAnalyse von I/O-Eingabe- und Ausgabebeispielen in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
