The File class

The

A
directory lister

Suppose

you’d like to see a directory listing. The

object can be listed in two ways. If you call

with no arguments, you’ll get the full list that the

object contains. However, if you want a restricted list, for example, all of

the files with an extension of

,

then you use a “directory filter,” which is a class that tells how

to select the

objects for display.

Here’s

the code for the example: (See page

if you have trouble executing this program.)

//: DirList.java
// Displays directory listing
package c10;
import java.io.*;
 
public class DirList {
  public static void main(String[] args) {
    try {
      File path = new File(".");
      String[] list;
      if(args.length == 0)
        list = path.list();
      else
        list = path.list(new DirFilter(args[0]));
      for(int i = 0; i < list.length; i++)
        System.out.println(list[i]);
    } catch(Exception e) {
      e.printStackTrace();
    }
  }
}
 
class DirFilter implements FilenameFilter {
  String afn;
  DirFilter(String afn) { this.afn = afn; }
  public boolean accept(File dir, String name) {
    // Strip path information:
    String f = new File(name).getName();
    return f.indexOf(afn) != -1;
  }
} ///:~ 

The

class “implements” the

.

(Interfaces were covered in Chapter 7.) It’s useful to see how simple the

is:

public interface FilenameFilter {
  boolean accept(File dir, String name);
}

It

says that all that this type of object does is provide a method called

.

The whole reason behind the creation of this class is to provide the

method to the

method so that

can

to determine which file names should be included in the list. Thus, this

technique is often referred to as a

shows that just because an

contains only a set of methods, you’re not restricted to writing only

those methods. (You must at least provide definitions for all the methods in an

interface, however.) In this case, the

constructor is also created.

The

method must accept a

object representing the directory that a particular file is found in, and a

containing the name of that file. You might choose to use or ignore either of

these arguments, but you will probably at least use the file name. Remember

that the

method is calling

for each of the file names in the directory object to see which one should be

included – this is indicated by the

result returned by

.

To

make sure that what you’re working with is only the name and contains no

path information, all you have to do is take the

object and create a

object out of it, then call

which strips away all the path information (in a platform-independent way). Then

uses the

The

method returns an array. You can query this array for its length and then move

through it selecting the array elements. This ability to easily pass an array

in and out of a method is a tremendous improvement over the behavior of C and

C++.

Anonymous
inner classes

This

example is ideal for rewriting using an

//: DirList2.java
// Uses Java 1.1 anonymous inner classes
import java.io.*;
 
public class DirList2 {
  public static FilenameFilter
  filter(final String afn) {
    // Creation of anonymous inner class:
    return new FilenameFilter() {
      String fn = afn;
      public boolean accept(File dir, String n) {
        // Strip path information:
        String f = new File(n).getName();
        return f.indexOf(fn) != -1;
      }
    }; // End of anonymous inner class
  }
  public static void main(String[] args) {
    try {
      File path = new File(".");
      String[] list;
      if(args.length == 0)
        list = path.list();
      else
        list = path.list(filter(args[0]));
      for(int i = 0; i < list.length; i++)
        System.out.println(list[i]);
    } catch(Exception e) {
      e.printStackTrace();
    }
  }
} ///:~ 

Note

that the argument to

must be

This

design is an improvement because the

class is now tightly bound to

.

However, you can take this approach one step further and define the anonymous

inner class as an argument to

,

in which case it’s even smaller:

//: DirList3.java
// Building the anonymous inner class "in-place"
import java.io.*;
 
public class DirList3 {
  public static void main(final String[] args) {
    try {
      File path = new File(".");
      String[] list;
      if(args.length == 0)
        list = path.list();
      else
        list = path.list(
          new FilenameFilter() {
            public boolean
            accept(File dir, String n) {
              String f = new File(n).getName();
              return f.indexOf(args[0]) != -1;
            }
          });
      for(int i = 0; i < list.length; i++)
        System.out.println(list[i]);
    } catch(Exception e) {
      e.printStackTrace();
    }
  }
} ///:~ 

The

argument to

is now

,

since the anonymous inner class uses

directly.

This

shows you how anonymous inner classes allow the creation of quick-and-dirty

classes to solve problems. Since everything in Java revolves around classes,

this can be a useful coding technique. One benefit is that it keeps the code

that solves a particular problem isolated together in one spot. On the other

hand, it is not always as easy to read, so you must use it judiciously.

A
sorted directory listing

Ah,

you say that you want the file names

?

Since there’s no support for sorting in Java 1.0 or Java 1.1

//: SortedDirList.java
// Displays sorted directory listing
import java.io.*;
import c08.*;
 
public class SortedDirList {
  private File path;
  private String[] list;
  public SortedDirList(final String afn) {
    path = new File(".");
    if(afn == null)
      list = path.list();
    else
      list = path.list(
          new FilenameFilter() {
            public boolean
            accept(File dir, String n) {
              String f = new File(n).getName();
              return f.indexOf(afn) != -1;
            }
          });
    sort();
  }
  void print() {
    for(int i = 0; i < list.length; i++)
      System.out.println(list[i]);
  }
  private void sort() {
    StrSortVector sv = new StrSortVector();
    for(int i = 0; i < list.length; i++)
      sv.addElement(list[i]);
    // The first time an element is pulled from
    // the StrSortVector the list is sorted:
    for(int i = 0; i < list.length; i++)
      list[i] = sv.elementAt(i);
  }
  // Test it:
  public static void main(String[] args) {
    SortedDirList sd;
    if(args.length == 0)
      sd = new SortedDirList(null);
    else
      sd = new SortedDirList(args[0]);
    sd.print();
  }
} ///:~ 

A

few other improvements have been made. Instead of creating

and

as local variables to

,

they are members of the class so their values can be accessible for the

lifetime of the object. In fact,

is now just a way to test the class. You can see that the constructor of the

class automatically sorts the list once that list has been created.

The

sort is case-insensitive so you don’t end up with a list of all the words

starting with capital letters, followed by the rest of the words starting with

all the lowercase letters. However, you’ll notice that within a group of

file names that begin with the same letter the capitalized words are listed

first, which is still not quite the desired behavior for the sort. This problem

will be fixed in Java 1.2

Checking
for and creating directories

The

class is more than just a representation for an existing directory path, file,

or group of files. You can also use a

object to create a new

//: MakeDirectories.java
// Demonstrates the use of the File class to
// create directories and manipulate files.
import java.io.*;
 
public class MakeDirectories {
  private final static String usage =
    "Usage:MakeDirectories path1 ...n" +
    "Creates each pathn" +
    "Usage:MakeDirectories -d path1 ...n" +
    "Deletes each pathn" +
    "Usage:MakeDirectories -r path1 path2n" +
    "Renames from path1 to path2n";
  private static void usage() {
    System.err.println(usage);
    System.exit(1);
  }
  private static void fileData(File f) {
    System.out.println(
      "Absolute path: " + f.getAbsolutePath() +
      "n Can read: " + f.canRead() +
      "n Can write: " + f.canWrite() +
      "n getName: " + f.getName() +
      "n getParent: " + f.getParent() +
      "n getPath: " + f.getPath() +
      "n length: " + f.length() +
      "n lastModified: " + f.lastModified());
    if(f.isFile())
      System.out.println("it's a file");
    else if(f.isDirectory())
      System.out.println("it's a directory");
  }
  public static void main(String[] args) {
    if(args.length < 1) usage();
    if(args[0].equals("-r")) {
      if(args.length != 3) usage();
      File
        old = new File(args[1]),
        rname = new File(args[2]);
      old.renameTo(rname);
      fileData(old);
      fileData(rname);
      return; // Exit main
    }
    int count = 0;
    boolean del = false;
    if(args[0].equals("-d")) {
      count++;
      del = true;
    }
    for( ; count < args.length; count++) {
      File f = new File(args[count]);
      if(f.exists()) {
        System.out.println(f + " exists");
        if(del) {
          System.out.println("deleting..." + f);
          f.delete();
        }
      }
      else { // Doesn't exist
        if(!del) {
          f.mkdirs();
          System.out.println("created " + f);
        }
      }
      fileData(f);
    }
  }
} ///:~ 

In

you can see the various file investigation methods put to use to display

information about the file or directory path.

The

first method that’s exercised by

is

If

you experiment with the above program, you’ll find that you can make a

directory path of any complexity because

|

|