Java - PushbackInputStream unread(byte[] b) method

---

---

Description

The Java PushbackInputStream unread(byte[] b) method pushes back an array of bytes by copying it to the front of the pushback buffer. After this method returns, the next byte to be read will have the value b[0], the byte after that will have the value b[1], and so forth.

unread(byte[] b) method −

• Pushes back (unreads) the entire byte array b into the stream.

• These bytes will be returned by the next calls to read().

• Commonly used in parsing scenarios where you need to "peek ahead" and then backtrack.

Declaration

Following is the declaration for java.io.PushbackInputStream.unread(byte[] b) method.

public void unread(byte[] b)

Parameters

b − The byte array to push back.

Return Value

This method does not return a value.

Exception

IOException − If there is not enough room in the pushback buffer for the specified number of bytes, or this input stream has been closed by invoking its close() method.

Example - Usage of PushbackInputStream unread(byte[] b) method

The following example shows the usage of PushbackInputStream unread(byte[] b) 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',};

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

      try {
         // 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]);
         }

         // change line
         System.out.println();

         // create a new byte array to be unread
         byte[] b = {'W', 'o', 'r', 'l', 'd'};

         // unread the byte array
         pis.unread(b);

         // read again 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 −

Hello
World

Example - Unread an entire byte array and read it back

The following example shows the usage of PushbackInputStream markSupported() 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) throws IOException {
      byte[] data = "12345".getBytes();
      byte[] buffer = new byte[5];

      try (PushbackInputStream pbis = new PushbackInputStream(new ByteArrayInputStream(data), 10)) {
         pbis.read(buffer, 0, 5); // Read all bytes
         System.out.println("Original: " + new String(buffer)); // Output: 12345

         pbis.unread(buffer); // Push back all bytes

         byte[] reread = new byte[5];
         pbis.read(reread); // Read them again
         System.out.println("After unread: " + new String(reread)); // Output: 12345
      }
   }
}

Output

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

Original: 12345
After unread: 12345

Explanation

• Reads all 5 bytes into buffer.

• Pushes them back using unread(buffer).

• Reads them again to confirm they were successfully unread.

Example - Peek at initial bytes, then unread them for re-processing

The following example shows the usage of PushbackInputStream unread(byte[] b) 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) throws IOException {
      byte[] data = "HelloWorld".getBytes();
      byte[] peek = new byte[5];
   
      try (PushbackInputStream pbis = new PushbackInputStream(new ByteArrayInputStream(data), 10)) {
         pbis.read(peek); // Peek first 5 bytes: "Hello"
         System.out.println("Peeked: " + new String(peek)); // Output: Hello

         // Push them back into the stream
         pbis.unread(peek);

         byte[] full = new byte[10];
         pbis.read(full); // Read full 10 bytes
         System.out.println("Full after unread: " + new String(full)); // Output: HelloWorld
      }
   }
}

Output

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

Peeked: Hello
Full after unread: HelloWorld

Explanation

• Peeks at first 5 bytes (Hello) to inspect the data.

• Pushes them back to the stream.

• Reads the full stream again from the beginning (HelloWorld).