Java BufferedInputStream-klasse

In deze zelfstudie leren we over Java BufferedInputStream en zijn methoden met behulp van voorbeelden.

De BufferedInputStream klasse van de java.io pakket wordt gebruikt met andere invoerstromen om de gegevens (in bytes) efficiënter te lezen.

Het verlengt de InputStream abstracte klasse.

Werking van BufferedInputStream

De BufferedInputStream onderhoudt een interne buffer van 8192 bytes .

Tijdens de leesbewerking in BufferedInputStream , wordt een stuk bytes van de schijf gelezen en opgeslagen in de interne buffer. En van de interne buffer worden bytes afzonderlijk gelezen.

Daarom wordt het aantal communicatie naar de schijf verminderd. Dit is de reden waarom het lezen van bytes sneller gaat met de BufferedInputStream .

Maak een BufferedInputStream

Om een ​​BufferedInputStream . aan te maken , moeten we de java.io.BufferedInputStream . importeren pakket eerst. Zodra we het pakket hebben geïmporteerd, kunnen we hier de invoerstroom maken.

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

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

In het bovenstaande voorbeeld hebben we een BufferdInputStream . gemaakt genaamd buffer met de FileInputStream genaamd bestand .

Hier heeft de interne buffer de standaardgrootte van 8192 bytes. We kunnen echter ook de grootte van de interne buffer specificeren.

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

De buffer helpt om bytes sneller uit de bestanden te lezen.

Methoden van BufferedInputStream

De BufferedInputStream class biedt implementaties voor verschillende methoden die aanwezig zijn in de InputStream klasse.

read()-methode

• read() - leest een enkele byte uit de invoerstroom
• read(byte[] arr) - leest bytes uit de stream en slaat op in de opgegeven array
• read(byte[] arr, int start, int length) - leest het aantal bytes gelijk aan de lengte uit de stream en slaat op in de opgegeven array vanaf de positie start

Stel dat we een bestand hebben met de naam input.txt met de volgende inhoud.

This is a line of text inside the file.

Laten we proberen het bestand te lezen met BufferedInputStream .

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();
        }
    }
}

Uitvoer

This is a line of text inside the file.

In het bovenstaande voorbeeld hebben we een gebufferde invoerstroom gemaakt met de naam buffer samen met FileInputStream . De invoerstroom is gekoppeld aan het bestand input.txt .

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

Hier hebben we de read() . gebruikt methode om een ​​array van bytes uit de interne buffer van de gebufferde lezer te lezen.

beschikbare() methode

Om het aantal beschikbare bytes in de invoerstroom te krijgen, kunnen we de available() . gebruiken methode. Bijvoorbeeld,

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();
      }
   }
}

Uitvoer

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

In het bovenstaande voorbeeld,

1. We gebruiken eerst de available() methode om het aantal beschikbare bytes in de invoerstroom te controleren.
2. Vervolgens hebben we de read() . gebruikt methode 3 keer om 3 bytes uit de invoerstroom te lezen.
3. Na het lezen van de bytes hebben we nu opnieuw de beschikbare bytes gecontroleerd. Deze keer zijn de beschikbare bytes met 3 afgenomen.

skip()-methode

Om het opgegeven aantal bytes te negeren en over te slaan, kunnen we de skip() . gebruiken methode. Bijvoorbeeld,

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();
      }
   }
}

Uitvoer

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

In het bovenstaande voorbeeld hebben we de skip() . gebruikt methode om 5 bytes over te slaan van de bestandsinvoerstroom. Vandaar dat de bytes 'T' , 'h' , 'i' , 's' en ' ' worden overgeslagen uit de invoerstroom.

close()-methode

Om de gebufferde invoerstroom te sluiten, kunnen we de close() . gebruiken methode. Zodra de close() methode wordt aangeroepen, kunnen we de invoerstroom niet gebruiken om de gegevens te lezen.

Andere methoden van BufferedInputStream

Ga voor meer informatie naar Java BufferdInputStream (officiële Java-documentatie).