Knowing the class constructors and methods

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

Creating a File object

To create a File object, you call the File constructor, passing a string representing the filename 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 usually is the directory from which the Java Virtual Machine (JVM) 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. You’re now entering one of the few areas of Java that becomes system-dependent, however, because the way you write pathnames depends on the operating system you’re using. The pathname c:logshits.log is valid for Windows systems, for example, but not on Unix or Macintosh systems, which don’t use drive letters and use forward slashes instead of backslashes to separate directories.

If you hard-code pathnames as string literals, the backslash character is the escape character for Java strings. Thus you must code two backslashes to get one backslash in the pathname. You must code the path c:logshits.log like this:

String path = "c:\logs\hits.log";

Creating a file

Creating a File object doesn’t create a file on the hard drive. Instead, it creates an in-memory object that represents a file or directory that may or may not actually exist on the hard drive. To find out whether the file or directory exists, you can use the exists method, as in this 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 the hard drive, create a File object with the filename you want to use and 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 the file was created successfully. If the file already exists, createNewFile returns false, so you don’t have to use the exists method before you call createNewFile.

When you create a file with the createNewFile method, the file doesn’t have anything in it. If you want the file to contain data, you can use the classes I describe in Book 8, Chapter 2, to write information to the file.

Getting information about a file

Several of the methods of the File class simply return information about a file or directory. You can find out whether the File object represents a file or directory, for example, by calling its isDirectory or isFile method. Other methods let you find out whether a file is read-only or hidden, or retrieve the file’s age and the time 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’s represented by an object of the File class. You can tell whether a particular File object is a directory by calling its isDirectory method. If this method returns true, the File is a directory. Then you can get an array of all the files contained in the directory by calling the listFiles method.

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 because it lists only files, not subdirectories, and 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());
}
}

Directory listings are especially well suited to recursive programming, because each File object returned by the listFiles method may be another directory that itself has a list of files and directories. For an explanation of recursive programming and an example that lists directories recursively, see Book 5, Chapter 4.

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 the file was renamed successfully.

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. 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.");

Always test the return value of the renameTo method to make sure that the file was renamed successfully.

Deleting a file

To delete a file, create a File object for the file and then call the delete method, as in this 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.

With some recursive programming, you can create a method that deletes a nonempty directory — but be sure to heed the upcoming warning. The method looks something like this:

private static void deleteFile(File dir)
{
File[] files = dir.listFiles();
for (File f : files)
{
if (f.isDirectory())
deleteFile(f);
else
f.delete();
}
dir.delete();
}

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

deleteFile(new File("folder1");

This feature is extremely dangerous to add to a program. Don’t use it without first testing it carefully. If you accidentally delete all the files on your hard drive, don’t blame me!

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:

• Create a File object for the directory and then pass the File object to the constructor.
• Pass the pathname for the directory where you want to start to the constructor.

The JFileChooser class also includes methods that let you control the appearance of the chooser dialog box. You can use the setDialogTitle method to set the title (the default is Open), for example, and you can use the setFileHidingEnabled method to control whether 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 choose files only with the file-chooser dialog box. The user can navigate 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.

In addition to an Open dialog box, you can display a Save dialog box by calling the showSaveDialog method. A Save dialog box is similar to an Open dialog box but has different default values for the title and the text shown on the Approve button. Otherwise these dialog boxes work pretty much the same way.

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, the return value is JFileChooser.APPROVE_OPTION.
• If the user clicked Cancel, the return value is JFileChooser.CANCEL_OPTION.
• If an I/O (input/output) or other error occurred, the return value is JFileChooser.ERROR_OPTION.

Assuming that the showOpenDialog method returns APPROVE_OPTION, you can 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, the method returns null.

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 use 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 create a class that extends the FileFilter abstract class and then 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 that you need to implement. This class is in the javax.swing.filechooser package.

For some reason, the Java designers gave this class the same name as an interface that’s in the java.io package, which is also frequently used in applications that work with files. As a result, you need to fully qualify this class when you extend it, like this:

class JavaFilter
extends javax.swing.filechooser.FileFilter

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 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 this 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 whether the file is of the type you’re looking for. 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 5, Chapter 3.)

Here’s a FileFilter 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 FileFilter class, like this:

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 the file filters that you add to the file chooser appear in the Files of Type drop-down list.

Creating files with the Paths class

One thing you may find confusing right off the bat is that the Path objects are created by calling a static method of the Paths class. Path and Paths are two distinct things: Path is an interface, and Paths is a class. To create a Path object, use the get method of the static Paths class, like this:

Path p = Paths.get("c:\test.txt");

Here the file’s name is test.txt, and it resides in the root directory of the C: drive.

Like a File object, a Path object represents a file that may or may not actually exist on the hard drive. You can test to see whether a file exists like this:

Path p = Paths.get(path);
if (!p.exists())
System.out.println
("The input file does not exist!");

To create a new file, use the createFile method, like this:

Path p = Paths.get("c:\test.txt");
try
{
p.createFile();
System.out.println ("File created!");
}
catch (Exception e)
{
System.out.println ("Error: " + e.getMessage());
}

Note that the createFile method throws an exception if the file couldn’t be created. The getMessage method of this exception returns a message that explains why the file couldn’t be created.

Getting the contents of a directory

One of the weaknesses of the File class is that it doesn’t deal well with large directories. In particular, methods such as listFiles that allow you to access the contents of a directory return an array of File objects. That’s fine if the directory contains a few dozen or even a few hundred files, but what if the directory contains thousands or tens of thousands of files? In short, the File class is not scalable.

The Path class remedies this deficiency by letting you access the contents of a directory via a stream object defined by DirectoryStream. I say more about working with streams in Book 8, Chapter 2, but for now, suffice it to say that a stream provides a simple way to access a large number of data items one at a time. You can retrieve the items in a directory stream easily by using an enhanced for statement, as in this example:

Path c = Paths.get("C:\");
try
{
DirectoryStream<Path> stream
= c.newDirectoryStream();
for (Path entry: stream)
System.out.println(entry.toString());
}
catch (Exception e)
{
System.out.println("Error: " + e.getMessage());
}

This example displays a listing of the contents of the C: directory, much as typing DIR C: at a command prompt would.

You could change the preceding example to list just the text files (files with the extension .txt) by changing the first statement after the try statement to this:

DirectoryStream<Path> stream
= c.newDirectoryStream("*.txt");