Question

can someone explain simply how to read a binary file and how to write to a binary file in java please

Answer 1

Read and Write Binary Files :-

When reading and writing binary files:
It's a good idea to use the buffer (Default buffer size is 8K).
It's possible to use references to the abstract base classes, instead of references to specific concrete classes.
There's a need to pay attentive to the exceptions (IOException and FileNotFoundException)

For read and write binary files using both File I/O API and new File I/O API (NIO).
The API (classes in the java.io.* package) is perfect for manipulate the low-level binary I/O operations such as read and write exactly one byte at a time
The NIO API (classes in the java.nio.* package) is more convenient for reading and writing the whole binary file at once.

We often use byte streams to read and write data in binary format, exactly 8bits.
All byte stream classes are inherited from the abstract classes InputStream and OutputStream.

The abstract class InputStream defines 2 main methods for read bytes from the input stream:-
1) read(): reads one byte of data (returns the byte as an integer value. Return -1 if the end of the file is reached.)
2) read(byte[]): reads a chunk of bytes to the specified byte array up to the size of the array.
(This method returns -1 if there’s no more data or the end of the file is reached).

Similarly the abstract class OutputStream defines 2 main methods for write bytes to the output stream:-
1) write(int):- write the specified byte to the output stream.
2) write(byte[]):- write the specified array of bytes to the output stream.

Example:-
import java.io.*;
public class copyFile{
public static void main(String[] args) {
if (args.length < 2) {
System.out.println("Please provide both input & output files");
System.exit(0);
}
String inputFile = args[0];
String outputFile = args[1];
   //Exception for handling I/O requests
try (
InputStream inputStream = new FileInputStream(inputFile);
OutputStream outputStream = new FileOutputStream(outputFile);
){
int byteRead;

while ((byteRead = inputStream.read()) != -1) {
outputStream.write(byteRead);
}

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

Command for compiling:-
compile before run :- javac copyFile.java
java copyFile java1st.zip java2nd.zip

Using BufferedInputStream and BufferedOutputStream is as same as the FileInputStream and FileOutputStream.
The only difference is that the buffered stream uses an array of bytes internally to buffer the input and output
to reduce the number of calls to the native API, hence it increases IO performance.

code :-
same as the above code but replaces the exception handling blocks with this.
try (
InputStream inputStream = new BufferedInputStream(new FileInputStream(inputFile));
OutputStream outputStream = new BufferedOutputStream(new FileOutputStream(outputFile));
) {

byte[] buffer = new byte[BUFFER_SIZE];

while (inputStream.read(buffer) != -1) {
outputStream.write(buffer);
}

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

we can set the memory(buffer) size for the buffer like this
int bufferSize = 20384; // 20KB buffer size
InputStream inputStream = new BufferedInputStream(new FileInputStream(inputFile), bufferSize);
OutputStream outputStream = new BufferedOutputStream(new FileOutputStream(outputFile), bufferSize);

The utility class files in the java.nio.file package provides the below methods for read and write binary data:-
1) readAllBytes(Path path1):- Reads all bytes from the file and returns an array of bytes.
This method is work for read small files, not large ones.
2) write(Path path1, byte[] bytes): writes an array of bytes to the file with some useful options like
CREATE, TRUNCATE_EXISTING, WRITE and APPEND.
Note that both methods close the input and output file after done and throw IOException in case of error.

code:-

import java.io.*;
import java.nio.file.*;
public class copyingFileNIO {
public static void main(String[] args) {
if (args.length < 2) {
System.out.println("Please provide both input & output files");
System.exit(0);
}
String inputFile = args[0];
String outputFile = args[1];
try {
long start1 = System.currentTimeMillis();
byte[] allBytes = Files.readAllBytes(Paths.get(inputFile));
Files.write(Paths.get(outputFile), allBytes);
long end1 = System.currentTimeMillis();
System.out.println("Copy in " + (end1 - start1) + " ms");
} catch (IOException ex) {
ex.printStackTrace();
}
}
}