Working with Files

In this chapter, you discover the ins and outs of working with files and directories. I don't show you how to read or write files, but you do find out how to find files on the disk, how to create, delete, or rename files, and how to work with directories. You find out how to use the Swing file chooser dialog box that lets you add filing capabilities to Swing applications. And finally, you find out how to retrieve parameters from the command line, a useful technique because command-line parameters are often used to pass file information to console programs.

Using the File Class

The File class is your key to processing files and directories. A File object represents a single file or directory. Note that the file or directory doesn't actually have to exist on disk. Instead, the File object represents a file that may or may not actually exist.

The File class is in the java.io package, so any program that uses it should import java.io.File or java.io.*.

Table 1-1 lists the main constructors and methods of the File class.

Table 1-1: The File Class

Open table as spreadsheet

Open table as spreadsheet

Open table as spreadsheet

Creating a File object

To create a File object, you call the File constructor, passing a string representing the filename of the file as a parameter. Here's an example:

File f = new File("hits.log");

Here the file's name is hits.log, and it lives in the current directory, which is usually the directory from which the Java Virtual Machine was started.

If you don't want the file to live in the current directory, you can supply a complete pathname in the parameter string. However, you're now entering one of the few areas of Java that becomes system-dependent, because the way you write pathnames depends on the operating system you're using. For example, c:logshits.log is a valid pathname for Windows systems, but not on Unix or Macintosh systems (which don't use drive letters and use forward slashes instead of backslashes to separate directories).

Creating a file

Creating a File object doesn't create a file on disk. Instead, it creates an in-memory object that represents a file or directory that may or may not actually exist on disk. To find out if the file or directory exists, you can use the exists method. For example:

File f = new File(path); if (!f.exists()) System.out.println ("The input file does not exist!");

Here an error message is displayed on the console if the file doesn't exist.

To create a new file on disk, first create a File object with the filename you want to use. Then use the createNewFile method, like this:

File f = new File(path); if (f.createNewFile()) System.out.println("File created."); else System.out.println("File could not be created.");

Note that the createNewFile method returns a boolean that indicates whether or not the file was successfully created. If the file already exists, createNewFile returns false, so you don't have to use the exists method before you call createNewFile.

Getting information about a file

Several of the methods of the File class simply return information about a file or directory. For example, you can find out if the File object represents a file or directory by calling its isDirectory or isFile method. Other methods let you find out if a file is read-only or hidden, or retrieve the file's age and when it was last modified.

You can get the name of the file represented by a File object in several popular ways:

• To get just the filename, use the getName method. This method returns a string that includes just the filename, not the complete path.
• To get the path that was specified to create the File object (such as logshit.log), use the toString method instead.
• To get the full path for a file-that is, the complete path including the drive letter (for Windows systems) and all the directories and subdirectories leading to the file-use the getCannonicalPath method. This method removes any system-dependent oddities such as relative paths, dots (which represent the current directory), and double-dots (which represent the parent directory) to get the file's actual path.

Getting the contents of a directory

A directory is a file that contains a list of other files or directories. Because a directory is just a special type of file, it is represented by an object of the File class. You can tell if a particular File object is a directory by calling its isDirectory method. If this method returns true, the File is a directory. You can then get an array of all the files contained in the directory by calling the listFiles method.

For example, the following code snippet lists the name of every file in a directory whose pathname is stored in the String variable path:

File dir = new File(path); if (dir.isDirectory()) { File[] files = dir.listFiles(); for (File f : files) System.out.println(f.getName()); }

The following snippet is a little more selective: It lists only files, not subdirectories, and it doesn't list hidden files:

File dir = new File(path); if (dir.isDirectory()) { File[] files = dir.listFiles(); for (File f : files) { if (f.isFile() && !f.isHidden()) System.out.println(f.getName()); } }

Renaming files

You can rename a file by using the renameTo method. This method uses another File object as a parameter that specifies the file you want to rename the current file to. It returns a boolean value that indicates whether or not the file was successfully renamed.

For example, the following statements change the name of a file named hits.log to savedhits.log:

File f = new File("hits.log"); if (f.renameTo(new File("savedhits.log"))) System.out.println("File renamed."); else System.out.println("File not renamed.");

Depending on the capabilities of the operating system, the renameTo method can also move a file from one directory to another. For example, this code moves the file hits.log from the folder logs to the folder savedlogs:

File f = new File("logs\hits.log"); if (f.renameTo(new File("savedlogs\hits.log"))) System.out.println("File moved."); else System.out.println("File not moved.");

Deleting a file

To delete a file, create a File object for the file, and then call the delete method. For example:

File f = new File("hits.log"); if (f.delete()) System.out.println("File deleted."); else System.out.println("File not deleted.");

If the file is a directory, the directory must be empty to be deleted.

Then, to delete a folder named folder1 along with all its files and subdirectories, call the deleteFile method:

deleteFile(new File("folder1");

Using Command Line Parameters

Ever since Book I, Chapter 1, I've used this construction in every Java program presented so far:

public static void main(String[] args)

It's high time you find out what the args parameter of the main method is used for. The args parameter is an array of strings that lets you access any command-line parameters that are specified by the user when he or she runs your program.

For example, suppose you run a Java program named Test from a command program like this:

C:>java Test the quick brown fox

In this case, the Java program is passed four parameters: the, quick, brown, and fox. You can access these parameters via the args array.

Suppose the main method of the Test class is written like this:

public static void main(String[] args) { for (String s : args) System.out.println(s); }

Then the program displays the following output on the console when run with the command shown a few paragraphs back:

the quick brown fox

Command-line parameters are useful in Java programs that work with files as a way to pass pathnames to the program. For example, here's a program that lists all the files in a directory passed to the program as a parameter:

import java.io.*; public class ListDirectory { public static void main(String[] args) { String path = args[0]; File dir = new File(path); if (dir.isDirectory()) { File[] files = dir.listFiles(); for (File f : files) { System.out.println(f.getName()); } } else System.out.println("Not a directory."); } }

Choosing Files in a Swing Application

For the most part, you don't want to mess around with command-line parameters in Swing applications. Instead, you want to use the JFileChooser class to let users pick the files they want to work with. This class lets you display Open and Save dialog boxes similar to the ones you've seen in other GUI applications with just a few lines of code.

For example, Figure 1-1 shows an Open dialog box created with just these two lines of code:

JFileChooser fc = new JFileChooser(); int result = fc.showOpenDialog(this);

Figure 1-1: An Open dialog box displayed by the JFileChooser class.

This code appears in a frame class that extends the JFrame class, so the this keyword in the showOpenDialog call refers to the parent frame.

The result returned by the showOpenDialog method indicates whether the user chose to open a file or click Cancel. And the JFileChooser class provides a handy getSelectedFile method you can use to get a File object for the file selected by the user.

Of course, the JFileChooser class has many additional methods you can use to tailor its appearance and behavior just about any way imaginable. Table 1-2 lists the commonly used constructors and methods of this powerful class.

Table 1-2: The JFileChooser Class

Open table as spreadsheet

Open table as spreadsheet

Creating an Open dialog box

As you've just seen, you can create an Open dialog box with just a few lines of code. First, you call the JFileChooser constructor to create a JFileChooser instance. Then you call the showOpenDialog method to display an Open dialog box.

If you don't pass a parameter to the constructor, the file chooser starts in the user's default directory, which on most systems is the operating system's current directory. If you want to start in some other directory, you have two options:

• You can create a File object for the directory, and then pass the File object to the constructor.
• You can just pass the pathname for the directory you want to start in to the constructor.

The JFileChooser class also includes methods that let you control the appearance of the chooser dialog box. For example, you can use the setDialogTitle method to set the title (the default is Open), and you can use the setFileHidingEnabled method to control whether or not hidden files are shown. If you want to allow the user to select more than one file, use the setMultiSelectionEnabled method.

A setFileSelectionMode method lets you specify whether users can select files, directories, or both. The options for this method need a little explanation:

• JFileChooser.FILES_ONLY: With this option, which is the default, the user can only choose files with the file chooser dialog box. The user can navigate through directories in the file chooser dialog box, but can't actually select a directory.
• JFileChooser.DIRECTORIES_ONLY: With this option, the user can select only directories, not files. One common use for this option is to let the user choose a default location for files used by your application without actually opening a file.
• JFileChooser.FILES_AND_DIRECTORIES: This option lets the user select either a file or a directory. For most applications, you want the user to pick either a file or a directory, but not both. So you probably won't use this option much.

Getting the selected file

The file chooser dialog box is a modal dialog box, which means that after you call the showOpenDialog method, your application is tied up until the user closes the file chooser dialog box by clicking the Open or Cancel button.

You can find out which button the user clicked by inspecting the value returned by the showOpenDialog method:

• If the user clicked Open, this value is

  JFileChooser.APPROVE_OPTION.

• If the user clicked Cancel, the return value is

  JFileChooser.CANCEL_OPTION.

• If an I/O or other error occurred, the return value is

  JFileChooser.ERROR_OPTION.

Assuming the showOpenDialog method returns APPROVE_OPTION, you can then use the getSelectedFile method to get a File object for the file selected by the user. Then you can use this File object elsewhere in the program to read or write data.

Putting it all together, then, here's a method that displays a file chooser dialog box and returns a File object for the file selected by the user. If the user cancels or an error occurs, null is returned:

private File getFile() { JFileChooser fc = new JFileChooser(); int result = fc.showOpenDialog(null); File file = null; if (result == JFileChooser.APPROVE_OPTION) file = fc.getSelectedFile(); return file; }

You can call this method from an action event handler when the user clicks a button, selects a menu command, or otherwise indicates that he or she wants to open a file.

Using file filters

The file chooser dialog box includes a Files of Type drop-down list filter that the user can choose to control what types of files are displayed by the chooser. By default, the only item available in this drop-down list is All Files, which doesn't filter the files at all. If you want to add another filter to this list, you must first create a class that extends the FileFilter abstract class. Then you pass an instance of this class to the addChoosableFileFilter method.

Table 1-3 lists the methods of the FileFilter class. Fortunately, it has only two methods you need to implement. This class is in the javax.swing. filechooser package.

The getDescription method simply returns the text displayed in the Files of Type drop-down list. You usually implement it with a single return statement that returns the description. Here's an example:

public String getDescription() { return "Java files (*.java)"; }

Here the string Java files (*.java) is displayed in the Files of Type drop-down list.

The accept method does the work of a file filter. The file chooser calls this method for every file it displays. The file is passed as a parameter. The accept method returns a boolean that indicates whether or not the file is displayed.

The accept method can use any criteria it wants to decide which files to accept and which files to reject. Most filters do it based on the file extension part of the filename. Unfortunately, the File class doesn't have a method that returns the file extension. But you can get the name with the getName method, and then use the matches method with a regular expression to determine if the file is of the type you're looking for. For example, here's an if statement that determines whether the filename in the name variable is a .java file:

if (name.matches(".*\.java"))

Here the regular expression matches strings that begin with any sequence of characters and end with .java. (For more information about regular expressions, refer to Book V, Chapter 3.)

Here's a complete file filter class that displays files with the extension .java:

private class javaFilter extends javax.swing.filechooser.FileFilter { public boolean accept(File f) { if (f.isDirectory()) return true; String name = f.getName(); if (name.matches(".*\.java")) return true; else return false; } public String getDescription() { return "Java files (*.java)"; } }

After you create a class that implements a file filter, you can add the file filter to the file chooser by calling the addChoosableFileFilter method, passing a new instance of the file filter class:

fc.setChoosableFileFilter(new JavaFilter());

If you want, you can remove the All Files filter by calling the method setAcceptAllFileFilterUsed, like this:

fc.setAcceptAllFileFilterUsed(false);

Then only file filters you add to the file chooser appear in the Files of Type drop-down list.