JFrame is a java swing container that can be used to create application windows. JFrames are the top most container in the swing applications. All the GUI components like labels, comboboxes are added into the JFrame. In this tutorial, we will learn how to make use of the Java JFrames to create swing applications and see how to manage the JFrame windows.

Simple application with JFrame

First, let’s create a simple application. We will add a button to the JFrame container.

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class JFrameTutorial {

  public static void main(String[] args) {
    //Create a JFrame
    JFrame jFrame = new JFrame("My JFrame Window!");
    //Set JFrame size
    jFrame.setSize(300, 200);

    //Create a JPanel to contain our button
    JPanel panel = new JPanel();
    //Add button to the panel
    panel.add(new JButton("Click Me"));

    //Attach panel to JFrame
    jFrame.add(panel);

    //Show the JFrame
    jFrame.setVisible(true);
  }
}

This will create the following output

Even though the above code works, it is not perfect. If you run the above code, you will have some questions. Let me make things clear for you.

Question: Even after the JFrame is closed, the application is still running in the background. Why does my application still run after closing the main window?

This is because you haven’t specified what to do when the JFrame is closed. Remember that in a real-world application, there will be many windows, so many JFrames. By default, if the JFrame was exiting/killing the application when it is closed, then this would cause countless issues. Because each window closing will cause the application to terminate by default.

To prevent this, when the close button is pressed, the JFrame just gets hidden and will not exit the application fully. To exit the application on window close, add the following line into the code to set setDefaultCloseOperation.

public static void main(String[] args) {
  JFrame frame = new JFrame("My JFrame Window!");
  frame.setSize(300, 200);
  JPanel panel = new JPanel();
  panel.add(new JButton("Click Me"));
  frame.add(panel);

  //Close the application when the window is closed
  frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

  frame.setVisible(true);
}

Question: The JFrame window is opening at the edge of the screen. How to make JFrame center on screen?

By default, the Window will appear at the edge of the screen (most of the time, in most of the common operating systems). To make the JFrame window appear at the dead center of the screen, you need to set the window’s location-relative-to null. It can be done as follows.

//Set location of the JFrame relative to null to get it open at the center of the screen
frame.setLocationRelativeTo(null);

Set Icon for JFrame Window

Very often, we will have to set our custom icon to the application window. With JFrame, this is possible with the method JFrame#setIconImage(Image). This will make the icon appear on the OS taskbar as well.

//Read the image you want to set as icon
Image image = ImageIO.read(JFrameTutorial.class.getResourceAsStream("/logo.png"));
//Set the image icon to window
frame.setIconImage(image);

If you would like to learn how to set up a system tray icon, have a look into this tutorial on setting up of tray-icon with menu in Java.

import java.awt.Image;
import java.io.IOException;
import javax.imageio.ImageIO;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class JFrameTutorial {
  public static void main(String[] args) throws IOException {
    JFrame frame = new JFrame("My JFrame Window!");
    frame.setSize(300, 200);
    JPanel panel = new JPanel();
    panel.add(new JButton("Click Me"));
    frame.add(panel);
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    frame.setLocationRelativeTo(null);
    frame.setIconImage(ImageIO.read(JFrameTutorial.class.getResourceAsStream("/logo.png")));
    frame.setVisible(true);
  }
}

Close/Hide JFrame Programmatically

Let’s say we want to close a JFrame programmatically. This can be done with JFrame#setVisible(false) method followed by a JFrame#dispose() method to clear the object. There is a deprecated function JFrame#hide(), but you should never use it as it has been deprecated from Java 1.5.

Simply set the visibility of the frame to false, and it will hide/close the window. Then call dispose() to release the system resources used by it.

//Set visibility to false for closing the JFrame
frame.setVisible(false);
//Dispose the frame to release resources
frame.dispose();

Another method for closing

Another easy method for closing the JFrame is by simulating the close button click event. As we have already seen, pressing the X button will close the window. We can simply simulate the close button click to close the JFrame itself. We can do that as follows

jFrame.dispatchEvent(new WindowEvent(frame, WindowEvent.WINDOW_CLOSING));

Maximize and minimize JFrame Programmatically

Now, let’s say we came across a requirement where we need to maximize a JFrame window programmatically. There is a function called JFrame#setExtendedState(int state) for programmatically maximizing and minimizing. Let’s see how we can do that with some code snippet.

private void minimizeJFrameWindow(JFrame jFrame) {
  //Minimize to task bar
  jFrame.setExtendedState(JFrame.ICONIFIED);
}

private void maximizeJFrameWindow(JFrame jFrame) {
  //Maximize the window
  jFrame.setExtendedState(JFrame.MAXIMIZED_BOTH);
}

private void maximizeJFrameWindowWidth(JFrame jFrame) {
  //Maximize the window only in the width (x-axis). Height will remain unchanged
  jFrame.setExtendedState(JFrame.MAXIMIZED_HORIZ);
}

private void maximizeJFrameWindowHeight(JFrame jFrame) {
  //Maximize the window only in the height (y-axis). Width will remain unchanged
  jFrame.setExtendedState(JFrame.MAXIMIZED_VERT);
}

Conclusion

In this tutorial, we have learned how to make use of JFrame to create windows in Java. We have seen how to create it, attach icon, center on screen, maximize and minimize etc. If you have liked this article, you might also like the following articles I have written.

• How to create Excel spreadsheets in Java
• Create animated GIF from still images in Java

In this tutorial, we will learn how to programmatically create animated GIF by combining multiple images in java easily. We will make use of the library gifencoder for this purpose.

Add the ‘gifencoder’ library to your project

If you are using Gradle, add the following dependency into your build.gradle file.

// https://mvnrepository.com/artifact/com.squareup/gifencoder
implementation group: 'com.squareup', name: 'gifencoder', version: '0.10.1'

If you are using the maven, add the following entry into your pom.xml file.

<!-- https://mvnrepository.com/artifact/com.squareup/gifencoder -->
<dependency>
    <groupId>com.squareup</groupId>
    <artifactId>gifencoder</artifactId>
    <version>0.10.1</version>
</dependency>

If you are using Java 9+ with modules, add the following line into your module-info.java file.

requires com.squareup.gifencoder;

Build GIF from multiple image files

First, let’s build our GIF from 4 image files. The steps for preparing the GIF from images as follows.

1. Convert the BufferedImages to int[][] pixel array
2. Provide the image pixel array into the encoder
3. Encode all the pixel array-based images into GIF image

Make sure that all the images you are using to prepare the GIF have the same size as that of the GIF. Automatic resizing of images is not done in the following code. If you want to do automatic resizing/cropping, take a look into the Thumbnailator library to do it easily.

import com.squareup.gifencoder.FloydSteinbergDitherer;
import com.squareup.gifencoder.GifEncoder;
import com.squareup.gifencoder.ImageOptions;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.concurrent.TimeUnit;
import javax.imageio.ImageIO;

public class JavaGifTutorial {

  public static void main(String[] args) throws Exception {
    JavaGifTutorial gifTutorial = new JavaGifTutorial();
    gifTutorial.createAnimatedGif();
  }

  private void createAnimatedGif() throws Exception {
    File image1 = new File("gifencoder/image1.jpg");
    File image2 = new File("gifencoder/image2.jpg");
    File image3 = new File("gifencoder/image3.jpg");
    File image4 = new File("gifencoder/image4.jpg");

    //The GIF image will be created with file name "my_animated_image.gif"
    try (FileOutputStream outputStream = new FileOutputStream("my_animated_image.gif")) {
      ImageOptions options = new ImageOptions();

      //Set 500ms between each frame
      options.setDelay(500, TimeUnit.MILLISECONDS);
      //Use Floyd Steinberg dithering as it yields the best quality
      options.setDitherer(FloydSteinbergDitherer.INSTANCE);

      //Create GIF encoder with same dimension as of the source images
      new GifEncoder(outputStream, 500, 313, 0)
          .addImage(convertImageToArray(image1), options)
          .addImage(convertImageToArray(image2), options)
          .addImage(convertImageToArray(image3), options)
          .addImage(convertImageToArray(image4), options)
          .finishEncoding(); //Start the encoding
    }
  }

  /**
   * Convert BufferedImage into RGB pixel array
   */
  public int[][] convertImageToArray(File file) throws IOException {
    BufferedImage bufferedImage = ImageIO.read(file);
    int[][] rgbArray = new int[bufferedImage.getHeight()][bufferedImage.getWidth()];
    for (int i = 0; i < bufferedImage.getHeight(); i++) {
      for (int j = 0; j < bufferedImage.getWidth(); j++) {
        rgbArray[i][j] = bufferedImage.getRGB(j, i);
      }
    }
    return rgbArray;
  }
}

Create GIF from all the images from a folder

Now, let’s see how we can improve the above code to take all the image files from a folder and use it to make an animated GIF. This way, you can simply put all the images you want to include the GIF image and run the code, no need to mention the individual images separately.

To achieve this, we need to add code for filtering only image files from a directory.

How to take only image files from a directory in Java?

Let’s see how to filter-out only JPEG and PNG files from a directory in Java. We will write code to iterate through all the files present in a directory, and then filter out only the image files by their extension.

private List<File> getAllImageFilesFromFolder(File directory) {
  //Get all the files from the folder
  File[] allFiles = directory.listFiles();
  if (allFiles == null || allFiles.length == 0) {
    throw new RuntimeException("No files present in the directory: " + directory.getAbsolutePath());
  }

  //Filter out only image files
  List<File> acceptedImages = new ArrayList<>();
  for (File file : allFiles) {
    String fileExtension = file.getName().substring(file.getName().lastIndexOf(".") + 1);
    if (fileExtension.equalsIgnoreCase("jpg") || fileExtension.equalsIgnoreCase("png")) {
      acceptedImages.add(file);
    }
  }

  //Return the filtered images
  return acceptedImages;
}

Create GIF from all the images in the folder

Now, let’s make use of the above function to get all the images from a folder and encode it into a GIF image.

//Trimmed code. Functions and imports used on the first section is excluded to keep the code compact

private void createAnimatedGifFromFolder(String path) throws Exception {
  //The GIF image will be created with file name "gif_from_folder.gif"
  try (FileOutputStream outputStream = new FileOutputStream("my_animated_image.gif")) {
    //Create GIF encoder with same dimension as of the source images
    GifEncoder encoder = new GifEncoder(outputStream, 1920, 1200, 0);

    //Get all the image files
    List<File> imageFiles = getAllImageFilesFromFolder(new File(path));

    //Make sure that at least one image is present
    if (imageFiles.isEmpty()) {
      throw new RuntimeException("No image files present!");
    }

    //Add all the images to the GifEncoder
    ImageOptions options = new ImageOptions();
    for (File imageFile : imageFiles) {
      encoder.addImage(convertImageToArray(imageFile), options);
    }

    //Finish encoding and create the file
    encoder.finishEncoding();
  }
}

private List<File> getAllImageFilesFromFolder(File directory) {
  File[] allFiles = directory.listFiles();
  List<File> acceptedImages = new ArrayList<>();
  for (File file : allFiles) {
    String fileExtension = file.getName().substring(file.getName().lastIndexOf(".") + 1);
    if (fileExtension.equalsIgnoreCase("jpg") || fileExtension.equalsIgnoreCase("png")) {
      acceptedImages.add(file);
    }
  }
  return acceptedImages;
}

That’s all. The function createAnimatedGifFromFolder(String folder) will go through all the JPG and PNG images available inside it and then use it to make the GIF animated image.

Conclusion

In this tutorial, we have learned how to create an animated GIF image a set of images in Java. Java GIF creation is done with the help of the gifencoder library. If you have liked this article, you might want to check out some of the other articles I have written.

• How to create Excel Spreadsheet in Java
• How to open file explorer from Java
• Java TrayIcon Tutorial

Sometimes, we come across requirements where we need to open a particular folder or directory in the native file explorer. In this tutorial, we will see how to do that, easy and effective.

Opening file explorer with java in any platform – Windows, Linux and Mac

The easiest way to do this is by using Java Desktop. The class provides an open() function Desktop#open(File) to open explorer when the given file is a directory.

private static void openDirectory() throws IOException {
  File directory = new File("C://Program Files//");
  Desktop.getDesktop().open(directory);
}

From Java 9 onwards, Desktop is available on the java.desktop module. So, make sure to add “requires java.desktop;” to your module-info.java file.

Open file explorer and select/highlight a file

Now, if you want to open the file explorer and have a file preselected, then there is a way for that as well! You can make use of Desktop.fileBrowseDirectory(File) to launch the file explorer and have a file highlighted. Let’s see a code example for the same.

However, before using this function, you have to keep the following things in mind.

• The code will not work on ALL platforms.
• You need to check whether the feature is supported via Desktop.getDesktop().isSupported(Action.BROWSE_FILE_DIR) function.
• Minimum Java 9 is required

import java.awt.Desktop;
import java.awt.Desktop.Action;
import java.io.File;

public class JavaFileExplorer {

  public static void main(String[] args) {
    openDirectory();
  }

  private static void openDirectory() {
    //Check if the feature supported on your platform
    if (Desktop.getDesktop().isSupported(Action.BROWSE_FILE_DIR)) {
      File directory = new File("/home/afsal/Downloads/jdk-8u212-linux-x64.tar.gz");
      //Open directory with browse_file_dir option
      Desktop.getDesktop().browseFileDirectory(directory);
    }
  }
}

Open file explorer in Linux

Now, if you would like to add specific code for Linux/Ubuntu to open the file explorer, have a look into the following code snippet. We can make use of the xdg-open command to open any directory. The good thing about using this method is that, it works across multiple Linux distributions. They just have to have the xdg-open support.

private static void openDirectoryInLinux() throws Exception {
  Runtime.getRuntime().exec(
     new String[]{"sh", "-c", "/usr/bin/xdg-open '/home/genuinecoder/Downloads/'"}
   );
}

Open file explorer in Windows

Now, if you would like to add specific code for Windows OS to open the file explorer, have a look into the following code snippet. We will execute a cmd command to open Windows explorer.exe.

private static void openDirectoryInWindows() throws Exception {
  Runtime.getRuntime().exec("explorer C:\\");
}

Open file explorer in MacOS

If you are looking for specific code for macOS, you can make use of the /usr/bin/open function to open the directory on macOS.

private static void openDirectoryInMac() throws Exception {
   Runtime.getRuntime().exec(new String[]{"/usr/bin/open", file.getAbsolutePath()});
}

Conclusion

In this tutorial, we have learned how to open a directory from a java program. We have numerous methods to achieve the same goal here. We can use java.awt.Desktop for platform independent support and if platform-specific implementation is required, that is also available. You might also be interested in the following topics.

1. Java TrayIcon Tutorial
2. Directory / Folder Indexing Program Using Java