Java - PushbackInputStream available() method

---

---

Description

The Java PushbackInputStream available() method returns an estimate of the number of bytes that can be read (or skipped over) from this input stream without blocking by the next invocation of a method for this input stream. The next invocation might be the same thread or another thread. A single read or skip of this many bytes will not block, but may read or skip fewer bytes.

The available() method

• Returns the number of bytes that can be read from the stream without blocking.

• Includes any bytes that have been pushed back using unread().

Declaration

Following is the declaration for java.io.PushbackInputStream.available() method.

public int available()

Parameters

NA

Return Value

This method returns the number of bytes that can be read (or skipped over) from the input stream without blocking.

Exception

IOException − If this input stream has been closed by invoking its close() method, or an I/O error occurs.

Example - Usage of PushbackInputStream available() method

The following example shows the usage of PushbackInputStream available() method.

PushbackInputStreamDemo.java

package com.tutorialspoint;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.PushbackInputStream;

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

      // declare a buffer and initialize its size:
      byte[] arrByte = new byte[1024];

      // create an array for our message
      byte[] byteArray = new byte[]{'H', 'e', 'l', 'l', 'o'};

      try {
         // create object of PushbackInputStream class for specified stream
         InputStream is = new ByteArrayInputStream(byteArray);
         PushbackInputStream pis = new PushbackInputStream(is);

         // check how many bytes are available
         System.out.println("" + pis.available());

         // read from the buffer one character at a time
         for (int i = 0; i < byteArray.length; i++) {

            // read a char into our array
            arrByte[i] = (byte) pis.read();

            // display the read byte
            System.out.print((char) arrByte[i]);
         }
      } catch (Exception ex) {
         ex.printStackTrace();
      }
   }
}

Output

Let us compile and run the above program, this will produce the following result −

5
Hello

Example - Check available bytes before and after pushback

The following example shows the usage of PushbackInputStream available() method.

PushbackInputStreamDemo.java

package com.tutorialspoint;

import java.io.ByteArrayInputStream;
import java.io.PushbackInputStream;
import java.io.IOException;

public class PushbackInputStreamDemo {
   public static void main(String[] args) {
      byte[] data = "ABC".getBytes();

      try (PushbackInputStream pbis = new PushbackInputStream(new ByteArrayInputStream(data))) {
         System.out.println("Available before read: " + pbis.available()); // Output: 3

         int ch = pbis.read(); // Read 'A'
         System.out.println("Read: " + (char) ch);

         pbis.unread(ch); // Push 'A' back into the stream
         System.out.println("Available after unread: " + pbis.available()); // Output: 3 again

      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

Output

Let us compile and run the above program, this will produce the following result−

Available before read: 3
Read: A
Available after unread: 3

Explanation

• The stream starts with 3 bytes ("ABC"), so available() initially returns 3.

• After reading 'A', available() would go down to 2, but we push 'A' back.

• After unread(), available() is 3 again.

Example - Read partially and check remaining bytes

The following example shows the usage of PushbackInputStream available() method.

PushbackInputStreamDemo.java

package com.tutorialspoint;

import java.io.ByteArrayInputStream;
import java.io.PushbackInputStream;
import java.io.IOException;

public class PushbackInputStreamDemo {
   public static void main(String[] args) {
      byte[] data = "1234567890".getBytes();

      try (PushbackInputStream pbis = new PushbackInputStream(new ByteArrayInputStream(data))) {
         byte[] buffer = new byte[4];
         pbis.read(buffer); // Read first 4 bytes: "1234"
         System.out.println("Read: " + new String(buffer));

         System.out.println("Available bytes after reading 4: " + pbis.available()); // Output: 6

      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

Output

Let us compile and run the above program, this will produce the following result−

Read: 1234
Available bytes after reading 4: 6

Explanation

• "1234567890" has 10 bytes. We read 4 bytes using a buffer.

• After that, 6 bytes are still available, so available() returns 6.