Home : Course Map : Chapter 9 : Java :
JFileChooser Dialog
JavaTech
Course Map
Chapter 9

Introduction
Overview
Streams
Wrappers,Buffers
Console I/O
  Text Output 
     Demo 1

  Formatter/printf()
     Demo 2

  Tex 2t Input
     Demo 3

  Scanner
     
Demo 4
File Class
  File I/O
  File Output-Text
     Demo 5

  Formatter to File
     Demo 6

  File Input - Text
    Demo 7

  Scanner - Files
     Demo 8

  File I/O - Binary
     Demo 9
   Demo 10
File Chooser Dialog
  Demo 11

Character Codes
  Demo 12
   Demo13
Object I/O
Types to Bytes
Stream Filters
Other I/O Topics
Exercises

    Supplements
Character I/O
  Demo 1   Demo 2
Random Access
  Demo 3
ZIP/GZIP Streams
  Demo 4
Piped Streams
  Demo 5
NIO Framework
More NIO
  Demo 6

     About JavaTech
     Codes List
     Exercises
     Feedback
     References
     Resources
     Tips
     Topic Index
     Course Guide
     What's New

To find files and directories on local media for input/output from a user interface, Swing provides the JFileChooser class. The file browser allows the user to search through directories and select one or more files and directores, which are then available via instances of File.

The example application below illustrates how to use JFileChooser to select files for reading and saving. The JFileChooser class methods allow customizing of the browser for open and save modes, for selecting single or multiple files, for setting the starting directory, and other options.

In addition, the chooser allows for filtering to display only lists of particular file types. This requires a subclass of the FileFilter class from the javax.swing.filechooser package. As shown by the class JavaFilter code below, by overriding the accept() method, you can examine the current file or directory and return false/true to reject or accept the current selection. You can verride getDescription() to return a string that describes the particular file types that the filter selects.

With a JTextArea component in the frame, we create a basic editor with a relatively short program.

File Chooser in Open Mode
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.io.*;

/**
  * Demonstrate the use of a JFileChooser to open and
  * save files. The chooser filers for *.java files. Opening
  * the file results in the text fillig a JTextArea component.
  * The text can be modified and saved to a new file.
 **/
public class FileChooseApp extends JFrame
       implements ActionListener
{

  JMenuItem fMenuOpen = null;
  JMenuItem fMenuSave  = null;
  JMenuItem fMenuClose = null;

  JTextArea fTextArea;

  JavaFilter fJavaFilter = new JavaFilter ();
  File fFile = new File ("default.java");

  /** Create a frame with JTextArea and a menubar
    * with a "File" dropdown menu.
   **/
  FileChooseApp (String title) {
    super (title);

    Container content_pane = getContentPane ();

    // Create a user interface.
    content_pane.setLayout ( new BorderLayout () );
    fTextArea = new JTextArea ("");

    content_pane.add ( fTextArea, "Center");


    // Use the helper method makeMenuItem
    // for making the menu items and registering
    // their listener.
    JMenu m = new JMenu ("File");

    // Modify task names to something relevant to
    // the particular program.
    m.add (fMenuOpen  = makeMenuItem ("Open"));
    m.add (fMenuOpen  = makeMenuItem ("Save"));
    m.add (fMenuClose = makeMenuItem ("Quit"));

    JMenuBar mb = new JMenuBar ();
    mb.add (m);

    setJMenuBar (mb);
    setSize (400,400);
  } // ctor

  /** Process events from the chooser. **/
  public void actionPerformed ( ActionEvent e ) {
    boolean status = false;

    String command = e.getActionCommand ();
    if  (command.equals ("Open")) {
    // Open a file
    status = openFile ();
    if (!status)
        JOptionPane.showMessageDialog (
          null,
          "Error opening file!", "File Open Error",
          JOptionPane.ERROR_MESSAGE
        );

    } else if (command.equals ("Save")) {
        // Save a file
        status = saveFile ();
        if (!status)
            JOptionPane.showMessageDialog (
              null,
              "IO error in saving file!!", "File Save Error",
              JOptionPane.ERROR_MESSAGE
            );

    } else if (command.equals ("Quit") ) {
        dispose ();
    }
  } // actionPerformed

  /** This "helper method" makes a menu item and then
    * registers this object as a listener to it.
   **/
  private JMenuItem makeMenuItem (String name) {
    JMenuItem m = new JMenuItem (name);
    m.addActionListener (this);
    return m;
  } // makeMenuItem

  /**
    * Use a JFileChooser in Open mode to select files
    * to open. Use a filter for FileFilter subclass to select
    * for *.java files. If a file is selected then read the
    * file and place the string into the textarea.
   **/
  boolean openFile () {

      JFileChooser fc = new JFileChooser ();
      fc.setDialogTitle ("Open File");

      // Choose only files, not directories
      fc.setFileSelectionMode ( JFileChooser.FILES_ONLY);

      // Start in current directory
      fc.setCurrentDirectory (new File ("."));

      // Set filter for Java source files.
      fc.setFileFilter (fJavaFilter);

      // Now open chooser
      int result = fc.showOpenDialog (this);

      if (result == JFileChooser.CANCEL_OPTION) {
          return true;
      } else if (result == JFileChooser.APPROVE_OPTION) {

          fFile = fc.getSelectedFile ();
          // Invoke the readFile method in this class
          String file_string = readFile (fFile);

          if (file_string != null)
              fTextArea.setText (file_string);
          else
              return false;
      } else {
          return false;
      }
      return true;
   } // openFile


  /**
    * Use a JFileChooser in Save mode to select files
    * to open. Use a filter for FileFilter subclass to select
    * for "*.java" files. If a file is selected, then write the
    * the string from the textarea into it.
   **/
   boolean saveFile () {
     File file = null;
     JFileChooser fc = new JFileChooser ();

     // Start in current directory
     fc.setCurrentDirectory (new File ("."));

     // Set filter for Java source files.
     fc.setFileFilter (fJavaFilter);

     // Set to a default name for save.
     fc.setSelectedFile (fFile);

     // Open chooser dialog
     int result = fc.showSaveDialog (this);

     if (result == JFileChooser.CANCEL_OPTION) {
         return true;
     } else if (result == JFileChooser.APPROVE_OPTION) {
         fFile = fc.getSelectedFile ();
         if (fFile.exists ()) {
             int response = JOptionPane.showConfirmDialog (null,
               "Overwrite existing file?","Confirm Overwrite",
                JOptionPane.OK_CANCEL_OPTION,
                JOptionPane.QUESTION_MESSAGE);
             if (response == JOptionPane.CANCEL_OPTION) return false;
         }
         return writeFile (fFile, fTextArea.getText ());
     } else {
       return false;
     }
  } // saveFile

  /** Use a BufferedReader wrapped around a FileReader to read
    * the text data from the given file.
   **/
  public String readFile (File file) {

    StringBuffer fileBuffer;
    String fileString=null;
    String line;

    try {
      FileReader in = new FileReader (file);
      BufferedReader dis = new BufferedReader (in);
      fileBuffer = new StringBuffer () ;

      while ((line = dis.readLine ()) != null) {
            fileBuffer.append (line + "\n");
      }

      in.close ();
      fileString = fileBuffer.toString ();
    }
    catch  (IOException e ) {
      return null;
    }
    return fileString;
  } // readFile


  /**
    * Use a PrintWriter wrapped around a BufferedWriter, which in turn
    * is wrapped around a FileWriter, to write the string data to the
    * given file.
   **/
  public static boolean writeFile (File file, String dataString) {
    try {
       PrintWriter out =
         new PrintWriter (new BufferedWriter (new FileWriter (file)));
       out.print (dataString);
       out.flush ();
       out.close ();
    }
    catch (IOException e) {
       return false;
    }
    return true;
  } // writeFile

  /** Create the framed application and show it. **/
  public static void main (String [] args) {
    // Can pass frame title in command line arguments
    String title="Frame Test";
    if (args.length != 0) title = args[0];
    FileChooseApp f = new FileChooseApp (title);
    f.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
    f.setVisible (true);
  } // main

}// class FileChooseApp
import javax.swing.*;
import java.io.*;

/** Filter to work with JFileChooser to select java file types. **/
public class JavaFilter extends javax.swing.filechooser.FileFilter
{
  public boolean accept (File f) {
    return f.getName ().toLowerCase ().endsWith (".java")
          || f.isDirectory ();
  }
 
  public String getDescription () {
    return "Java files (*.java)";
  }
} // class JavaFilter

References & Web Resources

Latest update: Nov. 13, 2004

              Tech
Histogram I/O
Hist I/O - Get/Set
  Demo 1
Hist I/O - Objects
  Demo 2
HistogramStream
  Demo 3
Filtering Data
  Demo 4
Exercises

           Physics
Physics Model
Simulation Design
Physics Simulator
  Demo 1
Experiment Design
Experiment Sim.
  Demo 2
Analysis
Expt. + Analysis
  Demo 3
Exercises

  Part I Part II Part III
Java Core 1  2  3  4  5  6  7  8  9  10  11  12 13 14 15 16 17
18 19 20
21
22 23 24
Supplements

1  2  3  4  5  6  7  8  9  10  11  12

Tech 1  2  3  4  5  6  7  8  9  10  11  12
Physics 1  2  3  4  5  6  7  8  9  10  11  12

Java is a trademark of Sun Microsystems, Inc.