English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
Dans ce tutoriel, nous allons apprendre Java BufferedInputStream et ses méthodes à l'aide d'exemples.
La classe BufferedInputStream du paquet java.io est utilisée avec d'autres flux d'entrée pour lire les données plus efficacement (en octets).
Il hérite de la classe abstraite InputStream.
BufferedInputStream gère un8192octetsdu tampon interne.
Pendant les opérations de lecture dans BufferedInputStream, une partie des octets est lue à partir du disque et stockée dans le tampon interne. Ensuite, les octets sont lus individuellement à partir du tampon interne.
Cela réduit le nombre de communications avec le disque. Voilà pourquoi lire des octets avec BufferedInputStream est plus rapide.
Pour créer un BufferedInputStream, nous devons d'abord importer le paquet java.io.BufferedInputStream. Après avoir importé le paquet, nous pouvons créer le flux d'entrée ici.
//Créer un FileInputStream FileInputStream file = new FileInputStream(String path); //创建一个BufferedInputStream BufferedInputStream buffer = new BufferedInputStream(file);
Dans l'exemple précédent, nous avons créé un buffer nommé BufferdInputStream et avons créé un fichier en utilisant FileInputStream nommé file.
Ici, la taille par défaut du tampon interne est8192Les octets. Mais, nous pouvons également spécifier la taille du tampon interne.
//Créer un BufferedInputStream avec un tampon interne de taille spécifiée BufferedInputStream buffer = new BufferedInputStream(file, int size);
Le buffer aidera à lire les octets à partir du fichier plus rapidement.
La classe BufferedInputStream fournit des implémentations pour différentes méthodes de la classe InputStream.
read() - Lire un octet à partir du flux d'entrée
read(byte[] arr) - Lire des octets à partir du flux et les stocker dans l'array spécifié
read(byte[] arr, int start, int length) - Lire un nombre d'octets égal à length à partir du flux et les stocker à partir de la position start dans l'array spécifié
Supposons que nous ayons un fichier nomméinput.txtle fichier, qui contient le contenu suivant.
Ceci est une ligne de texte à l'intérieur du fichier.
Essayons d'utiliser BufferedInputStream pour lire un fichier.
import java.io.BufferedInputStream;
import java.io.FileInputStream;
class Main {
public static void main(String[] args) {
try {
//Créer un FileInputStream
FileInputStream file = new FileInputStream("input.txt");
//创建一个BufferedInputStream
BufferedInputStream input = new BufferedInputStream(file);
//Lire le premier octet à partir du fichier
int i = input.read();
while (i != -1) {
System.out.print((char) i);
//Lire le prochain octet à partir du fichier
i = input.read();
}
input.close();
}
catch (Exception e) {
e.getStackTrace();
}
}
}Output result
Ceci est une ligne de texte à l'intérieur du fichier.
在上面的示例中，我们创建了一个名为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();
}
}
}Output result
开始时可用的字节数: 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);
//Skip5个字节
buffer.skip(5);
System.out.println("跳过5个字节后的输入流: ");
//从输入流中读取第一个字节
int i = buffer.read();
while (i != -1) {
System.out.print((char) i);
//Read the next byte from the input stream
i = buffer.read();
}
//Close the input stream
buffer.close();
}
catch (Exception e) {
e.getStackTrace();
}
}
}Output result
Skip5bytes after the input stream: is a line of text inside the file.
In the above example, we have used the skip() method to skip5bytes. Therefore, skip the bytes 'T', 'h', 'i', 's', and ' ' from the input stream.
To close the buffered input stream, we can use the close() method. Once the close() method is called, we will not be able to read data from the input stream.
| Method | Content description |
|---|---|
| mark() | Mark the position of the read data in the input stream |
| reset() | To return the control to the input stream at the marked point |