Skip to content Skip to sidebar Skip to footer
Home / How to Read a Binary File in Java Examples

How to Read a Binary File in Java Examples

Post a Comment
Details
Written past
Terminal Updated on 07 January 2022   | Impress Email

In this Java File IO tutorial, we bear witness you how to read and write binary files using both legacy File I/O API and new File I/O API (NIO). The legacy API (classes in the java.io.* package) is perfect for manipulating low-level binary I/O operations such every bit reading and writing exactly one byte at a time, whereas the NIO API (classes in the java.nio.* package) is more convenient for reading and writing the whole file at in one case, and of form, faster than the old File I/O API.

1. Understanding Byte Streams

We employ byte streams to read and write data in binary format, exactly 8-bit bytes. All byte stream classes are descended from the abstract classes InputStream and OutputStream. The post-obit class diagram depicts the chief classes in the legacy File I/O API that are designed for working with binary files:

Byte Streams API

You tin notice that these classes implement the AutoCloseable interface, which means that we tin use the try-with-resources structure to close these streams automatically.

At the height of the hierarchy, the abstract class InputStream defines two primary methods for reading bytes from an input stream:

  • read() : reads one byte of data, returns the byte every bit an integer value. Render -1 if the finish of the file is reached.
  • read(byte[]) : reads a chunk of bytes to the specified byte array, up to the size of the assortment. This method returns -1 if there'south no more data or the cease of the file is reached.

Similarly, the abstract grade OutputStream defines two primary methods for writing bytes to an output stream:

  • write(int) : writes the specified byte to the output stream.
  • write(byte[]) : writes the specified array of bytes to the output stream.

Moving down, the implementation classes FileInputStream and FileOutputStream are for reading and writing streams of raw bytes, ane or multiple bytes at a time. Whereas the BufferedInputStream and BufferedOutputStream are more than efficient by buffering the input stream and output stream to reduce the number of calls to the native API.

Now, let's see some code examples.

two. Reading and Writing Binary Files Using FileInputStream and FileOutputStream

The following examples use the FileInputStream and FileOutputStream classes to perform low level binary I/O.

This program copies one file to another, 1 byte at a fourth dimension. The source file and destination file are provided from control line's arguments:

import java.io.*; /**  * Copy one file to some other using depression level byte streams, i byte at a time.  * @writer www.codejava.net  */ public class CopyFiles {     public static void primary(String[] args) {  		if (args.length < 2) { 			Organization.out.println("Please provide input and output files"); 			System.exit(0); 		}  		Cord inputFile = args[0]; 		Cord outputFile = args[one];          try ( 			InputStream inputStream = new FileInputStream(inputFile); 			OutputStream outputStream = new FileOutputStream(outputFile);         ) {             int byteRead = -ane;              while ((byteRead = inputStream.read()) != -1) {                 outputStream.write(byteRead);             }          } catch (IOException ex) { 			ex.printStackTrace(); 		}     } }

Run this program like this:

coffee CopyFiles Project.zip Project1(1).aught

This program runs very ho-hum because information technology copies exactly i byte at a fourth dimension.

And the following program runs faster because it reads the whole input file into an array of bytes and then write the whole array of bytes to the output file:

import java.io.*; /**  * Copy 1 file to some other using depression level byte streams,  * read and write a whole.at in one case.  * @writer www.codejava.net  */ public grade CopyFilesOne {     public static void main(Cord[] args) {  		if (args.length < 2) { 			Organization.out.println("Please provide input and output files"); 			System.exit(0); 		}  		String inputFile = args[0]; 		String outputFile = args[i];          endeavor ( 			InputStream inputStream = new FileInputStream(inputFile); 			OutputStream outputStream = new FileOutputStream(outputFile);         ) { 			long fileSize = new File(inputFile).length();             byte[] allBytes = new byte[(int) fileSize];              int bytesRead = inputStream.read(allBytes);              outputStream.write(allBytes, 0, bytesRead);          } take hold of (IOException ex) { 			ex.printStackTrace(); 		}     } }

And the following program runs much faster past copying a chunk of bytes at a fourth dimension (exactly 4096 bytes at a time):

import java.io.*; /**  * Re-create ane file to another using depression level byte streams, 4KB at a fourth dimension.  * @writer world wide web.codejava.net  */ public class CopyFilesChunk { 	private static final int BUFFER_SIZE = 4096; // 4KB      public static void main(String[] args) { 		if (args.length < two) { 			System.out.println("Please provide input and output files"); 			System.exit(0); 		}  		String inputFile = args[0]; 		Cord outputFile = args[1];          endeavour ( 			InputStream inputStream = new FileInputStream(inputFile); 			OutputStream outputStream = new FileOutputStream(outputFile);         ) {             byte[] buffer = new byte[BUFFER_SIZE];             int bytesRead = -i;              while ((bytesRead = inputStream.read(buffer)) != -1) {                 outputStream.write(buffer, 0, bytesRead);             }          } catch (IOException ex) { 			ex.printStackTrace(); 		}     } }

The following program reads the starting time eight bytes of a file to place if information technology is a PNG image format or not:

import java.io.*; /**  * This program checks whether a file is of PNG image format or not,  * past analysing its outset 8 bytes.  * @author www.codejava.net  */ public class CheckPNG { 	private static int[] pngSignature = {137, 80, 78, 71, 13, x, 26, 10};      public static void main(String[] args) {  		if (args.length < 1) { 			System.out.println("Please provide the input file"); 			Organisation.exit(0); 		}  		String inputFile = args[0];          endeavour ( 			InputStream inputStream = new FileInputStream(inputFile);         ) { 			int[] headerBytes = new int[8]; 			boolean isPNG = truthful;  			for (int i = 0; i < 8; i++) {  				headerBytes[i] = inputStream.read();  				if (headerBytes[i] != pngSignature[i]) { 					isPNG = fake; 					break; 				} 			}  			System.out.println("Is PNG file? " + isPNG);          } catch (IOException ex) { 			ex.printStackTrace(); 		} 	} }

Run this programme similar this:

java CheckPNG Diagram.png

If the file is really a PNG image, it prints the output: Is PNG file? true

Equally you can come across, using FileInputStream and FileOutputStream is really good for low level binary I/O such equally analyzing a file or even create your ain file format.

3. Reading and Writing Binary Files Using BufferedInputStream and BufferedOutputStream

Using BufferedInputStream and BufferedOutputStream is as same as FileInputStream and FileOutputStream . The only departure is that a buffered stream uses an assortment of byte internally to buffer the input and output to reduce the number of calls to the native API, hence increasing IO performance.

Past default, both BufferedInputStream and BufferedOutputStream has an internal buffer of 8192 bytes (8KB), but we can specify a custom buffer size at initialization.

All the in a higher place examples tin can be re-written using buffered streams just by changing the instantiation of the streams. Here's an example:

endeavor ( 		InputStream inputStream = new BufferedInputStream(new FileInputStream(inputFile)); 		OutputStream outputStream = new BufferedOutputStream(new FileOutputStream(outputFile)); ) {     byte[] buffer = new byte[BUFFER_SIZE];     int bytesRead = -1;      while ((bytesRead = inputStream.read(buffer)) != -1) { 	    outputStream.write(buffer, 0, bytesRead);     } } take hold of (IOException ex) { 		ex.printStackTrace(); }

And we can specify a custom size for the buffer like this:

int bufferSize = 16384;	// 16KB buffer size InputStream inputStream 	= new BufferedInputStream(new FileInputStream(inputFile), bufferSize); OutputStream outputStream 	= new BufferedOutputStream(new FileOutputStream(outputFile), bufferSize);

iv. Reading and Writing Binary Files Using New File I/O API (NIO)

The utility class Files in the java.nio.file package provides the following methods for reading and writing binary information:

  • readAllBytes(Path path) : reads all bytes from a file and returns an array of bytes. This method is intended for reading minor files, non large ones.
  • write(Path path, byte[] bytes, OpenOption... options) : writes an array of bytes to a file with some useful options similar CREATE, TRUNCATE_EXISTING, WRITE and Suspend.

Notation that both methods shut the input and output file after done and throw IOException in instance of fault.

Permit's run into an example. The files copy programme above tin can exist re-written using NIO API like this:

import java.io.*; import java.nio.file.*; /**  * Copy one file to another using low level byte streams, one byte at a time.  * @author www.codejava.net  */ public form CopyFilesNIO {     public static void main(Cord[] args) {  		if (args.length < 2) { 			Organization.out.println("Please provide input and output files"); 			System.exit(0); 		}  		String inputFile = args[0]; 		String outputFile = args[1];          try { 			long start = System.currentTimeMillis(); 			byte[] allBytes = Files.readAllBytes(Paths.get(inputFile));  			Files.write(Paths.get(outputFile), allBytes);  			long terminate = System.currentTimeMillis();  			Organisation.out.println("Copied in " + (end - get-go) + " ms");         } catch (IOException ex) { 			ex.printStackTrace(); 		}     } }

Try to run this program and compare the time with the ones using legacy File I/O (on big files) you will see NIO performs much faster.

API References:

  • InputStream Javadoc
  • OutputStream Javadoc
  • FileInputStream Javadoc
  • FileOutputStream Javadoc
  • Files Javadoc
  • Paths Javadoc

Related File IO Tutorials:

  • How to Read and Write Text File in Java
  • How to read text file line by line in Java
  • Java IO FileInputStream and FileOutputStream Examples

Other Java File IO Tutorials:

  • How to list files and directories in a directory in Java
  • Java IO - Common File and Directory Operations Examples
  • Java Serialization Bones Example
  • Understanding Java Externalization with Examples
  • How to execute Operating Organization Commands in Java
  • 3 ways for reading user's input from console in Java
  • File modify notification example with Watch Service API
  • Java Scanner Tutorial and Code Examples

About the Author:

Nam Ha Minh is certified Coffee programmer (SCJP and SCWCD). He started programming with Coffee in the fourth dimension of Coffee 1.four and has been falling in honey with Coffee since then. Make friend with him on Facebook and watch his Coffee videos you lot YouTube.

Add annotate

darnelldound1953.blogspot.com

Source: https://www.codejava.net/java-se/file-io/how-to-read-and-write-binary-files-in-java

Post a Comment for "How to Read a Binary File in Java Examples"