Convert Byte to an Image in Java

A byte array is a fundamental data structure used to store binary data, making it a versatile tool for various tasks. One common use case is to store images in a byte array. In this section, we will explore how to convert a byte array into an image in Java. We will cover the entire process, from reading an image file and generating the byte array to creating a new image file from the byte array.

Converting Byte Array to Image

If we have image information stored as a byte array, you can reconstruct the image from that array. Java provides a set of classes and methods to facilitate this process, particularly in the javax.imageio package.

Reading the Image File and Creating the Byte Array

Read the image from a file using ImageIO.read(new File("Image path")).
Create an instance of the ByteArrayOutputStream class to store the image data.
Write the image into the ByteArrayOutputStream using ImageIO.write(image, "jpg", outStreamObj).
Convert the image into a byte array using byteArray = outStreamObj.toByteArray().

Generating a New Image File from the Byte Array

Create an instance of the ByteArrayInputStream class and initialize it with the byte array.
Read the image from the ByteArrayInputStream using ImageIO.read(inStreambj).
Create a new file and write the image into it using ImageIO.write(newImage, "jpg", new File("outputImage.jpg")).

Method 1: Using ImageIO

The method uses the ImageIO class from the Java standard library to read and write images. Here's the complete code:

ByteToImageConverter.java

import java.io.*;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
class ByteToImageConverter {
    public static void main(String[] args) {
        try {
            // Read the image from a file
            BufferedImage image = ImageIO.read(new File("image.jpg"));
            // Create a ByteArrayOutputStream to store the image data
            ByteArrayOutputStream outStreamObj = new ByteArrayOutputStream();
            // Write the image into the ByteArrayOutputStream
            ImageIO.write(image, "jpg", outStreamObj);
            // Convert the image into a byte array
            byte[] byteArray = outStreamObj.toByteArray();
            // Create a ByteArrayInputStream and initialize it with the byte array
            ByteArrayInputStream inStreambj = new ByteArrayInputStream(byteArray);
            // Read the image from the ByteArrayInputStream
            BufferedImage newImage = ImageIO.read(inStreambj);
            // Write the output image
            ImageIO.write(newImage, "jpg", new File("outputImage.jpg"));
            System.out.println("Image generated from the byte array.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Output:

Explanation

In Method 1, we use Java's built-in ImageIO class to convert a byte array to an image. The approach is based on a combination of ImageIO methods and ByteArrayInputStream and ByteArrayOutputStream. Here's how it works:

We start by reading an image from a file using ImageIO.read(new File("image.jpg")). This method loads the image into a BufferedImage.

To convert this BufferedImage into a byte array, we create a ByteArrayOutputStream. This stream acts as a temporary storage for image data.Next, we use ImageIO.write(image, "jpg", outStreamObj) to write the image data into the ByteArrayOutputStream. This process encodes the image into a byte array.We obtain the byte array by calling outStreamObj.toByteArray(). Now, the image is represented as a byte array.To recreate an image from the byte array, we create a ByteArrayInputStream initialized with the byte array. This stream allows us to read the image data.We use ImageIO.read(inStreambj) to read the image from the ByteArrayInputStream, resulting in a new BufferedImage.

Finally, we write the new BufferedImage to an output file using ImageIO.write(newImage, "jpg", new File("outputImageMethod1.jpg")). This step generates a new image file from the byte array.

Method 2: Using javax.imageio.ImageReader and ImageWriter

The method uses specific ImageReader and ImageWriter classes to read and write images. Here's the complete code:

ByteToImage.java

import java.awt.image.BufferedImage;
import javax.imageio.ImageIO;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageReader;
import javax.imageio.ImageWriter;
import javax.imageio.stream.ImageInputStream;
import javax.imageio.stream.ImageOutputStream;
public class ByteToImage {
    public static void main(String[] args) {
        try {
            // Read the image from a file
            ImageReader reader = ImageIO.getImageReadersByFormatName("png").next();
            File input = new File("image.png");
            ImageInputStream iis = ImageIO.createImageInputStream(input);
            reader.setInput(iis);
            BufferedImage image = reader.read(0);
            // Create a ByteArrayOutputStream to store the image data
            ByteArrayOutputStream outStreamObj = new ByteArrayOutputStream();
            ImageWriter writer = ImageIO.getImageWritersByFormatName("png").next();
            ImageOutputStream ios = ImageIO.createImageOutputStream(outStreamObj);
            writer.setOutput(ios);
            writer.write(image);
            // Convert the image into a byte array
            byte[] byteArray = outStreamObj.toByteArray();
            // Create a ByteArrayInputStream and initialize it with the byte array
            ByteArrayInputStream inStreambj = new ByteArrayInputStream(byteArray);
            // Read the image from the ByteArrayInputStream
            ImageReader newReader = ImageIO.getImageReadersByFormatName("png").next();
            ImageInputStream newIis = ImageIO.createImageInputStream(inStreambj);
            newReader.setInput(newIis);
            BufferedImage newImage = newReader.read(0);
            // Write the output image
            ImageIO.write(newImage, "png", new File("outputImageMethod2.png"));
            System.out.println("Image generated from the byte array using Method 2.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Output:

Explanation

Method 2 also leverages Java's javax.imageio package. Instead of directly using ImageIO, it employs specific ImageReader and ImageWriter classes. The process involves the following steps:

We read the image from a file using ImageIO.getImageReadersByFormatName("jpg").next(). This creates an ImageReader that understands the image format. We then read the image into a BufferedImage.

To convert the BufferedImage into a byte array, we create an ImageOutputStream. We associate this output stream with a ByteArrayOutputStream to store the image data. We use the ImageWriter to write the image data into the ImageOutputStream.

We retrieve the byte array from the ByteArrayOutputStream. To recreate the image from the byte array, we create a ByteArrayInputStream and initialize it with the byte array.

We read the image data from the ByteArrayInputStream using a new ImageReader, resulting in a new BufferedImage. Finally, we write the new BufferedImage to an output file, creating a new image file from the byte array.

Conclusion

Converting a byte array to an image in Java is a valuable skill for various applications. With the help of the javax.imageio package, we can efficiently transform image data into byte arrays and vice versa. The section provides a step-by-step guide and a complete Java program to perform this conversion successfully.

Next TopicCount Paths in Given Matrix in Java

← prev next →