Home » Desktop Java » awt » image » Java: Create BufferedImage from Image example

About Byron Kiourtzoglou

Byron Kiourtzoglou
Byron is a master software engineer working in the IT and Telecom domains. He is an applications developer in a wide variety of applications/services. He is currently acting as the team leader and technical architect for a proprietary service creation and integration platform for both the IT and Telecom industries in addition to a in-house big data real-time analytics solution. He is always fascinated by SOA, middleware services and mobile development. Byron is co-founder and Executive Editor at Java Code Geeks.

Java: Create BufferedImage from Image example

In this tutorial we are going to show you how to create a Buffered Image from a source Image. This is a basic operation if you want to perform several enchantments and transformations to your Image and its fundamental for Image processing.

In short, in order to create a BufferedImage from Image one should take the following steps:

  • Load an image from a source usingToolkit.getDefaultToolkit().getImage method
  • Use an ImageObserver to monitor the loading of the image. When the image is fully load the user will be notified
  • Create a buffed image from the source image with a format more close to the custom display environment using GraphicsEnvironmentGraphicsDevice and GraphicsConfiguration to perform several image configurations
  • Use graphics.drawImage(sourceImage, 0, 0, null) to draw the source image into the buffer and create the BuffferedImage
  • And simply paint the buffered image in a new Frame

Let’s take a look at the code snippet that follows:

package com.javacodegeeks.snippets.desktop;

import java.awt.Component;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.Image;
import java.awt.Toolkit;
import java.awt.Transparency;
import java.awt.image.BufferedImage;
import java.awt.image.ImageObserver;

public class ImageToBufferedImage {

  static BufferedImage image;
  static boolean imageLoaded = false;

  public static void main(String[] args) {

// The ImageObserver implementation to observe loading of the image

ImageObserver myImageObserver = new ImageObserver() {

  public boolean imageUpdate(Image image, int flags, int x, int y, int width, int height) {

    if ((flags & ALLBITS) != 0) {

imageLoaded = true;

System.out.println("Image loading finished!");

return false;


    return true;



// The image URL - change to where your image file is located!

String imageURL = "image.png";


  * This call returns immediately and pixels are loaded in the background

  * We use an ImageObserver to be notified when the loading of the image

  * is complete


Image sourceImage = Toolkit.getDefaultToolkit().getImage(imageURL);


// We wait until the image is fully loaded

while (!imageLoaded) {

    try {


    } catch (InterruptedException e) {



// Create a buffered image from the source image with a format that's compatible with the screen

GraphicsEnvironment graphicsEnvironment = GraphicsEnvironment.getLocalGraphicsEnvironment();

GraphicsDevice graphicsDevice = graphicsEnvironment.getDefaultScreenDevice();

GraphicsConfiguration graphicsConfiguration = graphicsDevice.getDefaultConfiguration();

// If the source image has no alpha info use Transparency.OPAQUE instead

image = graphicsConfiguration.createCompatibleImage(sourceImage.getWidth(null), sourceImage.getHeight(null), Transparency.BITMASK);

// Copy image to buffered image

Graphics graphics = image.createGraphics();

// Paint the image onto the buffered image

graphics.drawImage(sourceImage, 0, 0, null);


// Create frame with specific title

Frame frame = new Frame("Example Frame");

// Add a component with a custom paint method

frame.add(new CustomPaintComponent());

// Display the frame

int frameWidth = 300;

int frameHeight = 300;

frame.setSize(frameWidth, frameHeight);



   * To draw on the screen, it is first necessary to subclass a Component and
   * override its paint() method. The paint() method is automatically called
   * by the windowing system whenever component's area needs to be repainted.
  static class CustomPaintComponent extends Component {

public void paint(Graphics g) {

    // Retrieve the graphics context; this object is used to paint

    // shapes

    Graphics2D g2d = (Graphics2D) g;


     * Draw an Image object The coordinate system of a graphics context

     * is such that the origin is at the northwest corner and x-axis

     * increases toward the right while the y-axis increases toward the

     * bottom.


    int x = 0;

    int y = 0;

    g2d.drawImage(image, x, y, this);




This was an example on how to Create a BufferedImage from an Image.

0 0 vote
Article Rating

Do you want to know how to develop your skillset to become a Java Rockstar?

Subscribe to our newsletter to start Rocking right now!

To get you started we give you our best selling eBooks for FREE!


1. JPA Mini Book

2. JVM Troubleshooting Guide

3. JUnit Tutorial for Unit Testing

4. Java Annotations Tutorial

5. Java Interview Questions

6. Spring Interview Questions

7. Android UI Design


and many more ....


Receive Java & Developer job alerts in your Area


Notify of
The comment form collects your name, email and content to allow us keep track of the comments placed on the website. Please read and accept our website Terms and Privacy Policy to post a comment.

This site uses Akismet to reduce spam. Learn how your comment data is processed.

Inline Feedbacks
View all comments
Would love your thoughts, please comment.x