Java BufferedInputStream-Klasse

In diesem Tutorial lernen wir Java BufferedInputStream und seine Methoden anhand von Beispielen kennen.

Der BufferedInputStream Klasse der java.io Paket wird mit anderen Eingabeströmen verwendet, um die Daten (in Bytes) effizienter zu lesen.

Es erweitert die InputStream abstrakte Klasse.

Funktion von BufferedInputStream

Die BufferedInputStream verwaltet einen internen Puffer von 8192 Bytes .

Während des Lesevorgangs in BufferedInputStream , wird ein Teil der Bytes von der Festplatte gelesen und im internen Puffer gespeichert. Und aus dem internen Puffer werden Bytes einzeln gelesen.

Daher wird die Anzahl der Kommunikationen mit der Platte reduziert. Aus diesem Grund ist das Lesen von Bytes mit BufferedInputStream schneller .

Erstellen Sie einen BufferedInputStream

Um einen BufferedInputStream zu erstellen , müssen wir den java.io.BufferedInputStream importieren Paket zuerst. Sobald wir das Paket importiert haben, können wir hier den Eingabestrom erstellen.

// Creates a FileInputStream
FileInputStream file = new FileInputStream(String path);

// Creates a BufferedInputStream
BufferedInputStream buffer = new BufferInputStream(file);

Im obigen Beispiel haben wir einen BufferdInputStream erstellt mit dem Namen Puffer mit dem FileInputStream namens Datei .

Der interne Puffer hat hier die Standardgröße von 8192 Byte. Wir können jedoch auch die Größe des internen Puffers angeben.

// Creates a BufferedInputStream with specified size internal buffer
BufferedInputStream buffer = new BufferInputStream(file, int size);

Der Puffer wird helfen, Bytes aus den Dateien schneller zu lesen.

Methoden von BufferedInputStream

Die BufferedInputStream -Klasse stellt Implementierungen für verschiedene Methoden bereit, die in InputStream vorhanden sind Klasse.

read()-Methode

read() - liest ein einzelnes Byte aus dem Eingabestrom
read(byte[] arr) - liest Bytes aus dem Stream und speichert sie im angegebenen Array
read(byte[] arr, int start, int length) - liest die Anzahl der Bytes gleich der Länge aus dem Stream und speichert im angegebenen Array ab der Position start

Angenommen, wir haben eine Datei namens input.txt mit folgendem Inhalt.

This is a line of text inside the file.

Versuchen wir, die Datei mit BufferedInputStream zu lesen .

import java.io.BufferedInputStream;
import java.io.FileInputStream;

class Main {
    public static void main(String[] args) {
        try {

            // Creates a FileInputStream
            FileInputStream file = new FileInputStream("input.txt");

            // Creates a BufferedInputStream
            BufferedInputStream input = new BufferedInputStream(file);

            // Reads first byte from file
            int i = input .read();

            while (i != -1) {
                System.out.print((char) i);

                // Reads next byte from the file
                i = input.read();
            }
            input.close();
        }

        catch (Exception e) {
            e.getStackTrace();
        }
    }
}

Ausgabe

This is a line of text inside the file.

Im obigen Beispiel haben wir einen gepufferten Eingabestrom namens buffer erstellt zusammen mit FileInputStream . Der Eingabestream wird mit der Datei input.txt verknüpft .

FileInputStream file = new FileInputStream("input.txt");
BufferedInputStream buffer = new BufferedInputStream(file);

Hier haben wir den read() verwendet Methode zum Lesen eines Arrays von Bytes aus dem internen Puffer des gepufferten Lesegeräts.

available()-Methode

Um die Anzahl der verfügbaren Bytes im Eingabestrom zu erhalten, können wir den available() verwenden Methode. Zum Beispiel

import java.io.FileInputStream;
import java.io.BufferedInputStream;

public class Main {

   public static void main(String args[]) {

      try {

         // Suppose, the input.txt file contains the following text
         // This is a line of text inside the file.
         FileInputStream file = new FileInputStream("input.txt");
         
         // Creates a BufferedInputStream
         BufferedInputStream buffer = new BufferedInputStream(file);

         // Returns the available number of bytes
         System.out.println("Available bytes at the beginning: " + buffer.available());

         // Reads bytes from the file
         buffer.read();
         buffer.read();
         buffer.read();

         // Returns the available number of bytes
         System.out.println("Available bytes at the end: " + buffer.available());

         buffer.close();
      }

      catch (Exception e) {
         e.getStackTrace();
      }
   }
}

Ausgabe

Available bytes at the beginning: 39
Available bytes at the end: 36

Im obigen Beispiel

Wir verwenden zuerst den available() Methode, um die Anzahl der verfügbaren Bytes im Eingabestrom zu prüfen.
Dann haben wir den read() verwendet Methode dreimal, um 3 Bytes aus dem Eingabestrom zu lesen.
Nun, nach dem Lesen der Bytes haben wir noch einmal die verfügbaren Bytes überprüft. Diesmal verringerten sich die verfügbaren Bytes um 3.

skip()-Methode

Um die angegebene Anzahl von Bytes zu verwerfen und zu überspringen, können wir den skip() verwenden Methode. Zum Beispiel

import java.io.FileInputStream;
import java.io.BufferedInputStream;

public class Main {

   public static void main(String args[]) {

      try {
         // Suppose, the input.txt file contains the following text
         // This is a line of text inside the file.
         FileInputStream file = new FileInputStream("input.txt");

         // Creates a BufferedInputStream
         BufferedInputStream buffer = new BufferedInputStream(file);

         // Skips the 5 bytes
         buffer.skip(5);
         System.out.println("Input stream after skipping 5 bytes:");

         // Reads the first byte from input stream
         int i = buffer.read();
         while (i != -1) {
            System.out.print((char) i);

            // Reads next byte from the input stream
            i = buffer.read();
         }

         // Closes the input stream
         buffer.close();
      }

      catch (Exception e) {
         e.getStackTrace();
      }
   }
}

Ausgabe

Input stream after skipping 5 bytes: is a line of text inside the file.

Im obigen Beispiel haben wir den skip() verwendet Methode zum Überspringen von 5 Bytes aus dem Dateieingabestream. Daher die Bytes 'T' , 'h' , 'i' , 's' und ' ' werden aus dem Eingabestrom übersprungen.

close()-Methode

Um den gepufferten Eingabestrom zu schließen, können wir den close() verwenden Methode. Einmal die close() -Methode aufgerufen wird, können wir den Eingabestrom nicht zum Lesen der Daten verwenden.

Andere Methoden von BufferedInputStream

Methoden	Beschreibungen
`mark()`	Markieren Sie die Position im Eingabestrom, bis zu der Daten gelesen wurden
`reset()`	gibt die Kontrolle an den Punkt im Eingabestrom zurück, an dem die Markierung gesetzt wurde

Um mehr zu erfahren, besuchen Sie Java BufferdInputStream (offizielle Java-Dokumentation).

Java ObjectOutputStream-Klasse Java BufferedOutputStream-Klasse

Java