FileClass
FileReader stream may throw a FileNotFoundException. The way this happens is if the user provides a name for a file that either doesn’t exist or isn’t located where its name says it should be located. The question that needs to be considered: Is there any way we can detect these kinds of errors before attempting to read the file?
java.io.File class provides methods that we can use for this task. The File class provides a representation of the computer’s file and directory information in a platform-independent manner. As you know, a file is a collection of data, whereas a directory is a collection of files. (To be exact, a directory is a file that stores its files’ names and attributes, not the files themselves.) In this section, we will provide details about the File class and how to use the methods available in the class.
MyClass.class. When a program is running, the program’s directory is considered the current directory. Any files located in the current directory can be referred to by name alone—for example, MyClass.java. To refer to a file located in a subdirectory of the current directory, you need to provide the name of the subdirectory and the file: datafiles/data.txt. In this case, we are assuming a Linux file system, so we are using the / as the separator between the name of the directory (datafiles) and the name of the file (data.txt). This is an example of a relative path name, because we are specifying a file in relation to the current directory.
/root/java/examples/datafiles/data.txt
data.txt on a Linux system. When you supply the name of a file to one of the stream constructors, you are actually providing a path name. If the path consists of just a name, such as data.txt, Java assumes that the file is located in the same directory as the program itself.
File class (Figure 11.4.2) provides platform-independent methods for dealing with files and directories. It contains methods that list the contents of directories, determine a file’s attributes, and rename and delete files. Note the several static constants provided. These allow path names to be specified in a platform-independent way.
File.separator character will be the / and on a Windows system it will be the \,backslash. File.separator will be initialized to the appropriate separator for the particular system being used.
File class.File.separator constant instead of a literal value whenever you are specifying a path name.
File’s methods, let’s write a method that tests whether the file name entered by the user is the name of a valid, readable file.
String), and the method will return true if a readable file with that name exists. Otherwise, the method will throw an exception and return false:
private boolean isReadableFile(String fileName) {
try {
File file = new File(fileName);
if (!file.exists())
throw (new FileNotFoundException("No such File:"
+ fileName));
if (!file.canRead())
throw (new IOException("File not readable: "
+ fileName));
return true;
} catch (FileNotFoundException e) {
System.out.println("IOERROR: File NOT Found: "
+ fileName + "\n");
return false;
} catch (IOException e) {
System.out.println("IOERROR: " + e.getMessage() + "\n");
return false;
}
} // isReadableFile
File instance and uses its exists() and canRead() methods to check whether its name is valid. If either condition fails, an exception is thrown. The method handles its own exceptions, printing an error message and returning false in each case.
private boolean isWriteableFile(String fileName) {
try {
File file = new File (fileName);
if (fileName.length() == 0)
throw (new IOException("Invalid file name: "
+ fileName));
if (file.exists() && !file.canWrite())
throw (new IOException(
"IOERROR: File not writeable: " + fileName));
return true;
} catch (IOException e) {
display.setText("IOERROR: " + e.getMessage() + "\n");
return false;
}
} // isWriteableFile()
exists() method to test whether the user is attempting to write to an existing file. If so, we use the canWrite() method to test whether the file is writeable. Both kinds of errors result in IOExceptions.
File class (Figure 4.6.1) are just as easy to use as the ones we have illustrated in this section. Complete the getFileAttributes() method that takes the name of a file as its single parameter and prints the following information about the file: its absolute path, its length, and whether it is a directory or a file. The main() program is completed for you.
