How to Resize an Image with Java

X (Twitter) Facebook Pinterest LinkedIn

Resizing images is a common requirement in many Java applications, from web servers dynamically serving images at various resolutions to desktop applications that process and manipulate photographs. Java provides several ways to accomplish this task, leveraging both standard libraries and third-party tools. This article will guide you through the process of resizing an image in Java, covering a basic approach using the Java standard library (java.awt and javax.imageio) and introducing more advanced options for those needing extra flexibility and power.

Table of Contents

Resizing an Image Using Java’s Standard Library

The Java standard library offers a straightforward way to resize images through the java.awt.Image, java.awt.image.BufferedImage, and javax.imageio.ImageIO classes. This method is suitable for many applications, though it may lack some of the advanced features provided by third-party libraries.

Step 1: Read the Original Image

First, you need to read the image file you want to resize. This is done using the ImageIO.read(File input) method.

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

File inputFile = new File("path/to/original/image.jpg");
BufferedImage inputImage = ImageIO.read(inputFile);

Step 2: Create a Resized Image

Once you have the original image, you can create a resized version of it. This involves creating a new BufferedImage instance with the desired dimensions and then drawing the original image onto the new image at the new size.

int targetWidth = 100; // desired width
int targetHeight = 150; // desired height

BufferedImage outputImage = new BufferedImage(targetWidth, targetHeight, inputImage.getType());

Graphics2D graphics2D = outputImage.createGraphics();
// Use the Graphics2D object to draw the original image onto the new image
// with the desired width and height. The SCALE_SMOOTH option improves the resize quality
graphics2D.drawImage(inputImage, 0, 0, targetWidth, targetHeight, null);
graphics2D.dispose();

Step 3: Save the Resized Image

The last step is to write the resized image to a file. You can specify the file format (e.g., “JPG”, “PNG”) as the second parameter of the ImageIO.write(RenderedImage im, String formatName, File output) method.

File outputFile = new File("path/to/resized/image.jpg");
ImageIO.write(outputImage, "JPG", outputFile);

This process results in the original image being resized to the specified dimensions and saved to a new file.

Using Image.getScaledImage()

The getScaledInstance() method in Java’s Image class is used to create a scaled version of an existing image. This method can be particularly useful when you need to resize images for various purposes, such as thumbnail generation or adjusting images to fit into specific UI components. However, it’s worth noting that while getScaledInstance() is convenient, it’s often criticized for its performance and quality of the output image, especially for downscaling. For critical applications, consider using more advanced libraries like imgscalr for better results. But for simple use cases, getScaledInstance() can still be useful.

Here is a basic example of how to use getScaledInstance() to resize an image:

import javax.swing.ImageIcon;
import java.awt.Image;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;

public class ImageResizeExample {
    public static void main(String[] args) {
        try {
            // Load the original image
            File inputFile = new File("path/to/original/image.jpg");
            BufferedImage originalImage = ImageIO.read(inputFile);
            
            // Desired dimensions for the scaled image
            int scaledWidth = 100;
            int scaledHeight = 100;
            
            // Scale the image to the specified dimensions
            // The Image.SCALE_SMOOTH option is used for smoother scaling
            Image scaledImage = originalImage.getScaledInstance(scaledWidth, scaledHeight, Image.SCALE_SMOOTH);
            
            // Convert the scaled Image back to a BufferedImage for saving
            BufferedImage bufferedScaledImage = new BufferedImage(scaledWidth, scaledHeight, BufferedImage.TYPE_INT_RGB);
            bufferedScaledImage.getGraphics().drawImage(scaledImage, 0, 0, null);
            
            // Save the scaled image
            File outputFile = new File("path/to/scaled/image.jpg");
            ImageIO.write(bufferedScaledImage, "jpg", outputFile);
            
            System.out.println("Image resized successfully.");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

This code demonstrates how to:

Read an original image from a file using ImageIO.read().
Scale the image to new dimensions using getScaledInstance(). The SCALE_SMOOTH option is specified to improve the quality of the scaled image.
Convert the resulting Image back into a BufferedImage. This step is necessary because ImageIO.write() requires a BufferedImage object, and getScaledInstance() returns an Image object. The conversion is done by drawing the scaled Image onto a new BufferedImage.
Save the scaled image to a file using ImageIO.write().

Remember to replace "path/to/original/image.jpg" and "path/to/scaled/image.jpg" with the actual file paths for your input and output images.

While this approach is straightforward and part of the standard Java SDK, it’s essential to consider its limitations in terms of performance and result quality, especially for professional or high-quality image processing needs.

Advanced Image Resizing with Third-Party Libraries

For more advanced image processing needs, such as higher-quality resizing algorithms, handling of more image formats, or more complex transformations, third-party libraries like Thumbnailator, imgscalr, or ImageMagick (via the JMagick Java bindings) can be very useful.

Using Thumbnailator

Thumbnailator is a high-quality, easy-to-use Java library for image resizing. It simplifies the process to a single line of code while providing great results.

To use Thumbnailator, add it to your project’s dependencies. If you’re using Maven, include the following in your pom.xml:

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

Then, you can resize an image as follows:

import net.coobird.thumbnailator.Thumbnails;

Thumbnails.of("path/to/original/image.jpg")
        .size(targetWidth, targetHeight)
        .outputFormat("JPG")
        .toFile(new File("path/to/resized/image.jpg"));

Thumbnailator provides a fluent API that makes it simple to specify resizing options, output formats, and more, with excellent default choices for quality.

Using Imgscalr

First, ensure you have imgscalr included in your project. If you’re using Maven, you can add the following dependency to your pom.xml:

<dependency>
    <groupId>org.imgscalr</groupId>
    <artifactId>imgscalr-lib</artifactId>
    <version>4.2</version>
</dependency>

Now, let’s write a simple Java program that uses imgscalr to resize an image to a specific width and height, maintaining the original image’s aspect ratio for best visual quality. The program reads an image from the filesystem, resizes it, and then saves the resized image back to the filesystem.

import org.imgscalr.Scalr;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;

public class ImageResizeExample {
    public static void main(String[] args) {
        try {
            // Specify the path to the original image
            File originalImageFile = new File("path/to/original/image.jpg");
            // Specify the path where the resized image will be saved
            File resizedImageFile = new File("path/to/resized/image.jpg");

            // Read the original image from a file
            BufferedImage originalImage = ImageIO.read(originalImageFile);

            // Resize the image to 200 pixels width, maintaining aspect ratio
            // Use the high-quality resizing method
            BufferedImage resizedImage = Scalr.resize(originalImage, Scalr.Method.ULTRA_QUALITY, 200);

            // Write the resized image to a file
            // The image format is determined by the file extension (JPG in this case)
            ImageIO.write(resizedImage, "jpg", resizedImageFile);

            System.out.println("Image resized successfully.");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

This example demonstrates the basic usage of imgscalr for resizing an image. The Scalr.resize method is used to perform the actual resizing operation, with the Scalr.Method.ULTRA_QUALITY argument specifying that the library should use a higher quality (but slower) resizing algorithm. The 200 argument specifies the target width; the library automatically calculates the target height to maintain the original aspect ratio.

Remember to replace "path/to/original/image.jpg" and "path/to/resized/image.jpg" with the actual paths to your source and destination images.

imgscalr offers additional functionality, such as applying different types of filters, rotating, and cropping images, providing a simple yet powerful toolset for basic image processing tasks in Java applications.

Conclusion

Resizing images in Java can be accomplished using the standard library for straightforward needs, offering a simple way to adjust image dimensions with minimal dependencies. For applications requiring higher-quality results or more complex image processing, third-party libraries like Thumbnailator provide enhanced capabilities with an easy-to-use API. Whether you choose the Java standard library or a third-party solution, Java provides robust support for working with images, making it well-suited for applications that involve image manipulation.

Author
Recent Posts

Follow me

Anastasios Antoniadis

Anastasios Antoniadis is the founder and editor-in-chief of BORDERPOLAR... He is a software engineer, blogger, and avid gamer covering tech, gaming, and coding guides for over 4 years. He is a 2014 graduate of the Department of Informatics and Telecommunications of the University of Athens, an M.Sc. holder in Computer Science, and a Ph.D. student in Program Analysis.