Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.tutorialspoint.com/java/io/fileinputstream_read_byte_len.htm below:

FileInputStream read(byte[] b, int off, int len) method

The Java FileInputStream read(byte[] b, int off, int len) method reads upto len bytes of data from this input stream into an array of bytes, starting at offset off in the destination array b.

Following is the declaration for java.io.FileInputStream.read(byte[] b, int off, int len) method −

public int read(byte[] b, int off, int len)

• b − The byte array into which data is read.

• off − The start offset in the destination array b.

• len − The maximum number of bytes to be read.

The method returns the total number of bytes read into the buffer.

• IOException − If an I/O error occurs.

• NullPointerException − If b is null.

• IndexOutOfBoundsException − If len or off is negative, or b.length-off is greater than b.length.

The following example shows the usage of Java FileInputStream read(byte[] b, int off, int len) method.

package com.tutorialspoint;

import java.io.IOException;
import java.io.FileInputStream;

public class FileInputStreamDemo {
   public static void main(String[] args) throws IOException {
      FileInputStream fis = null;
      int i = 0;
      char c;
      byte[] bs = new byte[4];
      
      try {
         // create new file input stream
         fis = new FileInputStream("test.txt");
         
         // read bytes to the buffer
         i = fis.read(bs, 2, 1);
         
         // prints
         System.out.println("Number of bytes read: "+i);
         System.out.print("Bytes read: ");
         
         // for each byte in buffer
         for(byte b:bs) {
         
            // converts byte to character
            c = (char)b;
            if(b == 0)
               c = '-';
            
            // print
            System.out.print(c);
         } 
         
      } catch(Exception ex) {
         // if any error occurs
         ex.printStackTrace();
      } finally {
         // releases all system resources from the streams
         if(fis!=null)
            fis.close();
      }
   }
}

Assuming we have a text file test.txt in current directory, which has the following content. This file will be used as an input for our example program.

ABCDEF

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

Number of bytes read: 1
Bytes read: --A-

The following example shows the usage of Java FileInputStream read(byte[] b, int off, int len) method. This example reads data from a file using read(byte[] buf, int off, int len) method in chunks and prints it as text.

package com.tutorialspoint;

import java.io.FileInputStream;
import java.io.IOException;

public class FileInputStreamDemo {
   public static void main(String[] args) {
      try (FileInputStream fis = new FileInputStream("example.txt")) {
         byte[] buffer = new byte[10]; // Buffer of 10 bytes
         int bytesRead;

         while ((bytesRead = fis.read(buffer, 0, buffer.length)) != -1) {
            System.out.print(new String(buffer, 0, bytesRead)); // Convert bytes to String
         }
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

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

Hello, World!

• Opens example.txt using FileInputStream.

• Reads up to 10 bytes into buffer per iteration.

• Converts read bytes into a String and prints them.

• The loop continues until read() returns -1, indicating EOF.

• Uses try-with-resources to automatically close the stream.

The following example shows the usage of Java FileInputStream read(byte[] b, int off, int len) method. This example reads part of the file into a specific portion of an array.

package com.tutorialspoint;

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Arrays;

public class FileInputStreamDemo {
   public static void main(String[] args) {
      try (FileInputStream fis = new FileInputStream("example.txt")) {
         byte[] buffer = new byte[15]; // Larger buffer
         Arrays.fill(buffer, (byte) '-'); // Fill with '-'

         int bytesRead = fis.read(buffer, 5, 5); // Read 5 bytes, store at index 5

         System.out.println(new String(buffer)); // Print buffer contents
         System.out.println("Bytes read: " + bytesRead);
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

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

-----Hello-----
Bytes read: 5

• Initializes a 15-byte buffer filled with '-'.

• Reads 5 bytes from the file into buffer starting at index 5.

• Prints the entire buffer, showing where the data was stored.

• Also prints the number of bytes read.

java_io_fileinputstream.htm

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4