How to Compress Image in Java Source Code?

Image compression allows us to reduce the size of an image file without significantly compromising its visual quality. There are two types of compression. First, we use lossy compression to accept a reduced image quality while achieving a much smaller file size. For instance, we have JPEG and WebP formats for lossy compression. Second, we use lossless compression to preserve data and information during compression. For example, PNG and GIF formats are used during lossless compression.

Now, we will focus on lossy compression using the JPEG format, as it is the most used format on the internet. Afterward, we will check how to compress PNG images, known as PNG image optimization.

Compressing Image in Java

First, we'll use Java Image I/O's built-in API for reading and writing images. It supports various image formats, including JPEG, PNG, BMP, and GIF. Let's see how to compress an image using Java Image I/O.

First, we are reading the image from the resources file. Then, we create an ImageWriter for the JPG format, setting this writer's output file. Before we can write the image, we create the ImageWriteParam bject to define the compression mode and the compression quality to 50%. Finally, we write the image, close the output stream, and clean the writer.

For example, by compressing an example image by 50%, we almost reduced the file size from 790KB to 656KB, a little below 83% of the initial size. Hence, the change in the quality of the picture isn't noticeable:

ImageCompressor.java

import javax.imageio.ImageIO;
import javax.imageio.ImageWriteParam;
import javax.imageio.ImageWriter;
import javax.imageio.stream.ImageOutputStream;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.Iterator;
public class ImageCompressor {
    public static void compressImage(String inputPath, String outputPath) throws IOException {
        File inputFile = new File(inputPath);
        BufferedImage inputImage = ImageIO.read(inputFile);
        Iterator<ImageWriter> writers = ImageIO.getImageWritersByFormatName("jpg");
        ImageWriter writer = writers.next();
        File outputFile = new File(outputPath);
        ImageOutputStream outputStream = ImageIO.createImageOutputStream(outputFile);
        writer.setOutput(outputStream);
        ImageWriteParam params = writer.getDefaultWriteParam();
        params.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
        params.setCompressionQuality(0.5f);
        writer.write(null, new javax.imageio.IIOImage(inputImage, null, null), params);
        outputStream.close();
        writer.dispose();
    }
}

Compressing Image Using Thumbnails Library

The Thumbnails library is a straightforward and versatile library for resizing and compressing images. Let's first add the library to our pom.xml

<dependency>
    <groupId>net.coobird</groupId>
    <artifactId>thumbnailator</artifactId>
    <version>0.4.19</version>
</dependency>

Let's see how to compress an image using the Thumbnails class:

import net.coobird.thumbnailator.Thumbnails;
import net.coobird.thumbnailator.resizers.configurations.ScalingMode;
import java.io.File;
import java.io.IOException;
public class ImageCompressionExample {
    public static void main(String[] args) {
        try {
            File input = new File("input_image.jpg");
            File output = new File("output.jpg");
            Thumbnails.of(input)
                    .scale(1)  // This line scales the image to its original size (no scaling)
                    .outputQuality(0.5)  // Adjust the output quality (0.0 - 1.0)
                    .toFile(output);
            System.out.println("Image compression completed.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Output:

Image compression completed.

Compressing Images with Pngtastic Library

PNG optimization is a type of compression specifically designed for PNG images. We will use the Pngtastic library to optimize a PNG image. First, let's add the latest repository to our pom.xml

<dependency>
    <groupId>com.github.depsypher</groupId>
    <artifactId>pngtastic</artifactId>
    <version>1.7</version>
</dependency>

Finally, we can use the PngOptimizer class to compress a PNG file.

We use the optimize() method to let the library decide the best compression. Being a lossless compression, it is hard to reduce the size of the image significantly. Here, we reduced the size from 500 KB to 481 KB.

PNGOptimizationExample.java

import ar.com.hjg.pngj.ImageInfo;
import ar.com.hjg.pngj.PngImage;
import ar.com.hjg.pngj.PngOptimizer;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
public class PNGOptimizationExample {
    public static void main(String[] args) {
        String inputPath = "input.png";
        String outputPath = "output.png";
        try {
            // Load the input PNG image
            InputStream input = Files.newInputStream(Paths.get(inputPath));
            PngImage inputImage = new PngImage(input);
            // Create a PngOptimizer instance and optimize the input image
            PngOptimizer optimizer = new PngOptimizer();
            PngImage optimized = optimizer.optimize(inputImage);
            // Save the optimized image to the output file
            Path outputPathObj = Paths.get(outputPath);
            OutputStream output = Files.newOutputStream(outputPathObj);
            optimized.writeDataOutputStream(output);
            System.out.println("PNG optimization completed.?);
        }catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Output:

PNG optimization completed.

Conclusion

We have covered two approaches to lossy compression using Java the built-in Java Image I/O API and the Apache Commons Imaging library. Then, we used the Pngtastic library to do lossless compression on PNG images.

Next TopicHow to Download a File from a URL in Java

← prev next →