An introduction to I/O and the File and FileDialog classes in JAVA

Nearly all programs require the ability to transfer data in and out of memory. For example, data may be stored on disk or sent over a network.
Java provides many classes that make "I/O" (input and output) relatively easy and platform independent. In this article, you will learn how to act upon the file structure of a platform from inside a Java application. Note that Java applets are NOT permitted to access a platform's file structure for security reasons.

The File class
· Is part of the java.io package. You will need an import statement to access the class with its abbreviated name. 
· Is an extension of the Object class 

Object 

       File 

· Encapsulates platform-independent information about a file or a directory. 
While all platforms use pathname strings to name files and directories, they do not agree on the format of these strings. For example, the Windows pathname string is not the same as the Unix pathname string. 
Regardless of platform, however, all pathnames have two components: 

1. An optional system-dependent prefix string (such as the disk-drive specifier followed by "/" for the Unix root directory or "" for the Windows root directory) 

2. A sequence of zero or more string names where each name, except for the last, denotes a directory. The the last name may denote either a directory or a file. A system-dependent separator ("/" for Unix or "" for Windows) is used between each name. 
For example, the following represents a valid Windows pathname: 
C:My DocumentsNew CoursesArticle55.htm

Regardless of the platform, the File class presents a system-independent view of pathnames. 

· Has a number of static fields. These two are the most useful: 

For example, the following program can determine if it is running under Windows:
import java.io.*;
public class App {
public static void main(String[] args) {
if (File.separator.equals(""))
System.out.println("Windows");
else
System.out.println("Not Windows");
}
}

Note that the double backslash is required to because a single backslash denotes an escape sequence.
· Has several constructors. The most frequently used constructs a File object from a pathname string as shown by the following statement: 
File f = new File("C:My DocumentsMiscResume.doc");
NOTE: Constructing a File object does NOT create a disk file. It only constructs a platform-independent object for referencing the file. 
· Has a number of methods, some of which WILL create, rename, and delete a disk file or a directory. They should obviously be used with caution. The most frequently used methods are: 

Consult the Java API documentation for more details.

The FileDialog class
· Is part of the java.awt package. You will need an import statement to access the class with its abbreviated name. 
· Has many ancestor classes as indicated by the following diagram: 

Object 

       Component 

              Container 

                    Window 

                         Dialog 

                                FileDialog

· Can be instantiated to display a modal dialog window from which the user can select a file. Because it is a modal dialog, once an application makes a FileDialog object visible, it cannot continue until the user has chosen a file. 
· Has two static fields that indicate whether the file will be used for input or output. They are 

· Has several constructors. The most frequently used is demonstrated by 
FileDialog fd = new FileDialog(this, "Choose file", FileDialog.LOAD);
fd.setVisible(true);
which constructs and displays a file dialog window for the current (this) object. The title of the file dialog window will be "Choose file", and the chosen file will be used for input. 
· Has a number of methods. The most frequently used are as follows: 

Consult the Java API documentation for more details.

Sample program 

The following menu-driven, Windows program uses the File and FileDialog classes to display a variety of information about a file selected by the user: 

While the File and FileDialog classes allow a program to act upon the file structure of a platform, they do NOT allow for the actual storage and retrieval of data. That is covered in the next article.

In the previous article, you learned how to uses Java's I/O streams to write data to disk and read data from disk. In both cases, the organization of the file was sequential. All file data was written or read one item after another.

Sequential files are useful, but they do not provide a way to quickly locate an item of data without reading through all the other items of data that precede it. They also do not provide a means of updating an item of data without copying the entire file.
In this article, you will learn the essentials of Java's RandomAccessFile class, which permits a program to directly access an item of data and replace its contents.

The RandomAccessFile class

· Is part of the java.io package 
· Is an extension of the Object class. It does NOT descend from the InputStream or OutputStream classes. 
Object 

RandomAccessFile

· Is a high-level class that can be used to directly read or write primitive data items and UTF strings to a file. The file behaves like a large array of bytes. By positioning a pointer ("seeking") to a byte location within the file, a particular item of data may be either read or written. 
· Has two constructors. The most frequently used requires two parameters 

1. The reference of a File object that contains the pathname of the file. 
2. A String that represents the mode of access. It must be either "r" (read only) or "rw" (read/write). 

For example, if fd is the reference of a File object

RandomAccessFile raf = new RandomAccessFile(fd, "rw");

will construct a RandomAccessFile object for both reading and writing primitive values and UTF strings to the file. Because a checked, IOException may occur, the statement should be enclosed in a try block with an appropriate catch. 
· Has many useful methods as follows: 

Notes:

1. All read and write methods automatically advance the pointer to the next data item within the file. 
2. Because a checked, IOException may occur, calls to these methods should be enclosed in a try block with an appropriate catch. Consult the Java API documentation for more details. 

· Example. The following program creates a file of 100 integers. The user is then allowed to directly read and change the value of selected integers within the file. The final contents of the file are then displayed. 

Limitations and solutions

The usefulness of the RandomAccessFile class is severely restricted by its inability to read and write objects. For example, it would be difficult to use a RandomAccessFile to process a file of Customer objects.

The simplest solution to this problem is to use a Map collection (such as a HashMap) for the objects. All collections are serializable. In a single I/O operation, the entire Map can be written to disk using an ObjectOutputStream or read from disk using an ObjectInputStream. The get() and put() methods can be used to access the collection's objects while the Map is in memory.
The author you can reach on dineshnair@hotmail.com

Language: Java
Platform: Independent