How to Read in Doubles in Java

Details

Written by

Last Updated on 07 Jan 2022   | Print Email

In this Java File IO tutorial, nosotros show 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 depression-level binary I/O operations such as 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 once, and of course, faster than the sometime File I/O API.

i. Understanding Byte Streams

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

You can notice that these classes implement the AutoCloseable interface, which ways that we tin use the try-with-resource construction to shut these streams automatically.

At the meridian of the bureaucracy, the abstract course InputStream defines two chief methods for reading bytes from an input stream:

• read() : reads i byte of data, returns the byte as an integer value. Return -1 if the end of the file is reached.
• read(byte[]) : reads a clamper of bytes to the specified byte array, up to the size of the array. This method returns -1 if there's no more than data or the end of the file is reached.

Similarly, the abstruse course 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 fourth dimension. Whereas the BufferedInputStream and BufferedOutputStream are more efficient past buffering the input stream and output stream to reduce the number of calls to the native API.

Now, let's see some code examples.

2. 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 programme copies i file to some other, one byte at a fourth dimension. The source file and destination file are provided from command line'due south arguments:

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

Run this plan like this:

java CopyFiles Project.zip Project1(i).cypher

This program runs very slow considering it copies exactly one byte at a time.

And the following plan runs faster because information technology reads the whole input file into an array of bytes and and so write the whole array of bytes to the output file:

import coffee.io.*; /**  * Copy one file to another using low level byte streams,  * read and write a whole.at once.  * @writer www.codejava.net  */ public class CopyFilesOne {     public static void primary(Cord[] args) {  		if (args.length < 2) { 			Organisation.out.println("Please provide input and output files"); 			System.go out(0); 		}  		String inputFile = args[0]; 		Cord outputFile = args[1];          try ( 			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);          } grab (IOException ex) { 			ex.printStackTrace(); 		}     } }

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

import java.io.*; /**  * Copy one file to another using low level byte streams, 4KB at a time.  * @author www.codejava.net  */ public course CopyFilesChunk { 	individual static final int BUFFER_SIZE = 4096; // 4KB      public static void main(Cord[] args) { 		if (args.length < ii) { 			Organisation.out.println("Please provide input and output files"); 			System.go out(0); 		}  		String inputFile = args[0]; 		String outputFile = args[ane];          try ( 			InputStream inputStream = new FileInputStream(inputFile); 			OutputStream outputStream = new FileOutputStream(outputFile);         ) {             byte[] buffer = new byte[BUFFER_SIZE];             int bytesRead = -1;              while ((bytesRead = inputStream.read(buffer)) != -1) {                 outputStream.write(buffer, 0, bytesRead);             }          } grab (IOException ex) { 			ex.printStackTrace(); 		}     } }

The following program reads the first 8 bytes of a file to place if it is a PNG image format or not:

import java.io.*; /**  * This program checks whether a file is of PNG prototype format or not,  * by analysing its commencement 8 bytes.  * @author www.codejava.cyberspace  */ public grade CheckPNG { 	private static int[] pngSignature = {137, fourscore, 78, 71, 13, 10, 26, ten};      public static void primary(String[] args) {  		if (args.length < 1) { 			System.out.println("Please provide the input file"); 			System.exit(0); 		}  		Cord inputFile = args[0];          try ( 			InputStream inputStream = new FileInputStream(inputFile);         ) { 			int[] headerBytes = new int[eight]; 			boolean isPNG = true;  			for (int i = 0; i < 8; i++) {  				headerBytes[i] = inputStream.read();  				if (headerBytes[i] != pngSignature[i]) { 					isPNG = faux; 					break; 				} 			}  			System.out.println("Is PNG file? " + isPNG);          } catch (IOException ex) { 			ex.printStackTrace(); 		} 	} }

Run this program like this:

java CheckPNG Diagram.png

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

Every bit y'all can see, using FileInputStream and FileOutputStream is really skillful for low level binary I/O such every bit analyzing a file or even create your own file format.

3. Reading and Writing Binary Files Using BufferedInputStream and BufferedOutputStream

Using BufferedInputStream and BufferedOutputStream is as aforementioned equally FileInputStream and FileOutputStream . The but difference is that a buffered stream uses an array of byte internally to buffer the input and output to reduce the number of calls to the native API, hence increasing IO performance.

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

All the above examples can be re-written using buffered streams simply by changing the instantiation of the streams. Here's an example:

try ( 		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);     } } catch (IOException ex) { 		ex.printStackTrace(); }

And we tin 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);

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

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

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

Annotation that both methods close the input and output file afterwards done and throw IOException in case of error.

Permit'due south see an instance. The files copy programme to a higher place tin can be re-written using NIO API like this:

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

Effort to run this program and compare the time with the ones using legacy File I/O (on big files) you volition 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 Coffee
• Java IO FileInputStream and FileOutputStream Examples

Other Coffee File IO Tutorials:

• How to list files and directories in a directory in Java
• Java IO - Common File and Directory Operations Examples
• Coffee Serialization Basic Instance
• Understanding Coffee Externalization with Examples
• How to execute Operating System Commands in Java
• 3 ways for reading user'due south input from panel in Java
• File change notification example with Lookout man Service API
• Java Scanner Tutorial and Code Examples

Virtually the Author:

Nam Ha Minh is certified Java programmer (SCJP and SCWCD). He started programming with Java in the fourth dimension of Java one.4 and has been falling in honey with Java since so. Brand friend with him on Facebook and scout his Java videos yous YouTube.

Add comment

mcdougaldbegicke.blogspot.com

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

Share this post