English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
In diesem Tutorial werden wir durch Beispiele lernen, wie man Java BufferedInputStream und seine Methoden verwendet.
Die Klasse BufferedInputStream aus dem java.io-Paket wird zusammen mit anderen Eingabestromen verwendet, um Daten effizienter zu lesen (in Form von Bytes).
es hat die InputStream-Abstrakte Klasse geerbt.
BufferedInputStream unterhält einen8192Bytesder internen Puffer.
Während des Lesens in einem BufferedInputStream werden einige Bytes von der Festplatte gelesen und im internen Puffer gespeichert. Und die Bytes werden einzeln aus dem internen Puffer gelesen.
Das reduziert die Anzahl der Kommunikationen mit der Festplatte. Dies ist der Grund, warum das Lesen von Bytes mit dem BufferedInputStream schneller ist.
Um einen BufferedInputStream zu erstellen, müssen wir zunächst das Paket java.io.BufferedInputStream importieren. Nach dem Importieren des Pakets können wir hier den Eingabestrom erstellen.
//Eine FileInputStream erstellt FileInputStream file = new FileInputStream(String path); //创建一个BufferedInputStream BufferedInputStream buffer = new BufferInputStream(file);
Im obigen Beispiel haben wir einen Puffer namens BufferdInputStream erstellt und mit einem FileInputStream namens file eine Datei erstellt.
Hier beträgt die Standardgröße des internen Puffers8192Bytes. Aber wir können auch die Größe des internen Puffers angeben.
//Erstelle einen BufferedInputStream mit einer bestimmten internen Puffergröße BufferedInputStream buffer = new BufferInputStream(file, int size);
Der Puffer hilft dabei, schneller Bytes aus der Datei zu lesen.
Die BufferedInputStream-Klasse bietet verschiedene Methoden der InputStream-Klasse Implementierungen.
read() - Ein Byte aus dem Eingabestrom lesen
read(byte[] arr) - Lese Bytes aus dem Stream und speichere sie im angegebenen Array
read(byte[] arr, int start, int length) - Lese eine Anzahl von Bytes aus dem Stream, die gleich der Länge sind, und speichere sie ab Position start im angegebenen Array
Angenommen, wir haben eine Datei namensinput.txtmit folgendem Inhalt.
Dies ist ein Zeilen-text innerhalb der Datei.
Lassen Sie uns versuchen, den BufferedInputStream zur Dateilektüre zu verwenden.
import java.io.BufferedInputStream;
import java.io.FileInputStream;
class Main {
public static void main(String[] args) {
try {
//Eine FileInputStream erstellt
FileInputStream file = new FileInputStream("input.txt");
//创建一个BufferedInputStream
BufferedInputStream input = new BufferedInputStream(file);
//Den ersten Byte aus der Datei lesen
int i = input.read();
while (i != -1) {
System.out.print((char) i);
//Den nächsten Byte aus der Datei lesen
i = input.read();
}
input.close();
}
catch (Exception e) {
e.getStackTrace();
}
}
}Ausgaberesultat
Dies ist ein Zeilen-text innerhalb der Datei.
在上面的示例中，我们创建了一个名为buffer的缓冲输入流和FileInputStream。输入流与文件input.txt链接。
FileInputStream file = new FileInputStream("input.txt");
BufferedInputStream buffer = new BufferedInputStream(file);在这里，我们使用了read()方法从缓冲读取器的内部缓冲区读取字节数组。
要获取输入流中可用字节的数量，我们可以使用available()方法。例如，
import java.io.FileInputStream;
import java.io.BufferedInputStream;
public class Main {
public static void main(String args[]) {
try {
//假设input.txt文件包含以下文本
//这是文件中的一行文本。
FileInputStream file = new FileInputStream("input.txt");
//创建一个BufferedInputStream
BufferedInputStream buffer = new BufferedInputStream(file);
//返回可用的字节数
System.out.println("开始时可用的字节数: " + buffer.available());
//从文件中读取字节
buffer.read();
buffer.read();
buffer.read();
//返回可用的字节数
System.out.println("结束时的可用字节数: " + buffer.available());
buffer.close();
}
catch (Exception e) {
e.getStackTrace();
}
}
}Ausgaberesultat
开始时可用的字节数: 39 结束时的可用字节数: 36
在以上示例中，
我们首先使用available()方法检查输入流中可用字节的数量。
然后，我们使用read()方法3次从输入流中读取3个字节。
现在，在读取字节之后，我们再次检查了可用字节。这一次可用字节减少了3。
要丢弃和跳过指定的字节数，可以使用skip()方法。例如
import java.io.FileInputStream;
import java.io.BufferedInputStream;
public class Main {
public static void main(String args[]) {
try {
//假设input.txt文件包含以下文本
//这是文件中的一行文本。
FileInputStream file = new FileInputStream("input.txt");
//创建一个BufferedInputStream
BufferedInputStream buffer = new BufferedInputStream(file);
//Überspringen5个字节
buffer.skip(5);
System.out.println("跳过5个字节后的输入流: ");
//从输入流中读取第一个字节
int i = buffer.read();
while (i != -1) {
System.out.print((char) i);
//Nächsten Byte aus dem Eingabestrom lesen
i = buffer.read();
}
//Schließe den Eingabestrom
buffer.close();
}
catch (Exception e) {
e.getStackTrace();
}
}
}Ausgaberesultat
Überspringen5Byte nach dem Input Stream: is a line of text inside the file.
Im obigen Beispiel haben wir die skip() Methode verwendet, um Bytes zu überspringen5Byte. Daher werden die Bytes „T“,
Um einen buffered Input Stream zu schließen, können wir die close() Methode verwenden. Sobald die close() Methode aufgerufen wird, können wir den Input Stream nicht mehr zum Lesen von Daten verwenden.
| Methode | Inhaltsbeschreibung |
|---|---|
| mark() | Markiert den Lesepunkt im Eingabestrom |
| reset() | Kontrollen zurück zum markierten Punkt im Eingabestrom setzen |