Verwendung von Java BufferedInputStream anhand von Beispielen

Der BufferedInputStream in Java hat die Fähigkeit dazu lesen die Daten aus dem Puffer. Der Puffer-Eingabestream ist nützlich zum Speichern von Daten. Der gepufferte Eingabestream ist sehr effektiv bei der Reduzierung der Anzahl der E/A-Vorgänge, was letztendlich zur Leistungssteigerung beiträgt.

In diesem Artikel befassen wir uns insbesondere mit dem Java BufferedInputStream.

Wie verwende/implementiere ich Java BufferedInputStream anhand von Beispielen?

Der Java BufferedInputStream ist für das Lesen der Daten aus dem Stream verantwortlich. Es nutzt den internen Puffer, um die Leistung zu beschleunigen. Die Leistung wird auch erhöht, da weniger Vorgänge ausgeführt werden, wodurch die Anwendungen schneller ausgeführt werden.

Werfen wir einen Blick auf die Syntax des Eingabepufferstroms.

Syntax

FileInputStream fileip = new FileInputStream("D:\\filename.txt");
BufferedInputStream buffip = new BufferedInputStream(fileip);

Beispiel 1: Lesen der Datei

Mit der Methode read() können Sie den in der Datei verfügbaren Text lesen. Hier ist ein Codierungsbeispiel, das Ihnen hilft zu verstehen, wie Daten aus einem Stream gelesen werden:

import java.io.*;

//Declare class for Buffered input stream
class bufferedstream {
    public static void main(String args[]) {
        try {
            // Create a file along with its location
            FileInputStream fileip = new FileInputStream("D:\\bufferedstream.txt");
            //The built-in function for BufferedInputStream.
            BufferedInputStream buffip = new BufferedInputStream(fileip);
            // Declare an integer.
            int j;
            // When the file reaches the end.
            while ((j = buffip.read()) != -1) {
                System.out.print((char) j);
            }
            // close() method closes the stream.
            buffip.close();
            fileip.close();
            // Exception to be thrown for any further operations on the stream.
        } catch (Exception x) {
            System.out.println(x);
        }
    }
}

Im obigen Code,

  • Der Speicherort der Datei wurde über FileInputStream eingegeben.
  • Der BufferedInputStream ruft dann den jeweiligen im Dateistream deklarierten Dateinamen auf.
  • Die while-Schleife zur Deklaration der read()-Methode, wenn die Datei das Ende erreicht, während die read()-Methode ausgeführt wurde.
  • Der Stream wurde mit geschlossen schließen() Methode in Java.

Ausgabe

Die obige Ausgabe enthält den in die Datei geschriebenen Text.

Beispiel 2: Available()-Methode

Die Anzahl der in der Textdatei verfügbaren Bytes wird mit der Methode available() ermittelt.

import java.io.*;
//Create a class for available bytes.
class newstream {
    public static void main(String args[]) {
        try {
            //Enter the file name along with its location.
            FileInputStream file = new FileInputStream("D:\\bufferedstream.txt");
            //The buffered input stream
            BufferedInputStream buffer = new BufferedInputStream(file);
            //The number of bytes available at the start of the buffer
            System.out.println("The bytes in the starting are: " + buffer.available());

            buffer.read();
            buffer.read();
            //The number of bytes that are present at the end of the buffer
            System.out.println("The bytes in the end are: " + buffer.available());
            //Close the buffer
            buffer.close();
        }
        //Exception case
        catch (Exception e) {
            e.getStackTrace();
        }
    }
}

Der obige Code:

  • Der Code ähnelt dem vorherigen, mit dem Unterschied, dass die Methode read() zweimal aufgerufen wurde.
  • Diese read()-Methode bewirkt, dass die Endbytes um das Doppelte verringert werden.
  • Die Methode „available()“ gibt die Anzahl der Bytes am Anfang und am Ende an, die in der angegebenen Datei vorhanden sind.

Ausgabe

Die obige Ausgabe veranschaulicht Folgendes:

  • Die Startbytes sind 85.
  • Die Endbytes wurden zweimal verringert, also 83.

Dieser Artikel fasst die Implementierung von BufferedInputStream im Detail zusammen.

Abschluss

Der Java BufferedInputstream ist für das Lesen der Daten in Bytes verantwortlich. Es funktioniert so, dass die Bytes intern im Puffer gespeichert werden und diese Bytes dann einzeln aus dem internen Puffer gelesen werden. Durch das Lesen der Daten aus dem Puffer wird die Systemleistung beschleunigt. In diesem Artikel wurde die Funktionsweise von Java BufferedInputStream anhand von Beispielen demonstriert.

Kommentar verfassen

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

Nach oben scrollen