12.1 Datei und Verzeichnis

Da durch Datenströme keine Dateien gelöscht oder umbenannt werden können, liefert uns ein File-Objekt Informationen über Dateien und Verzeichnisse. Dieses Objekt wurde eingeführt, um Dateioperationen plattformunabhängig durchzuführen. Dies bedeutet aber leider auch eine Einschränkung, denn wie sollten Rechte vergeben werden, wenn etwa der Macintosh mit Mac OS 9 oder ein Palm-Pilot das nicht unterstützt? Auch Unix und Windows haben zwei völlig verschiedene Ansätze zur Rechteverwaltung.

12.1.1 Dateien und Verzeichnisse mit der Klasse File

Ein konkretes File-Objekt repräsentiert eine Datei oder ein Verzeichnis im Dateisystem. Der Verweis wird durch einen Pfadnamen spezifiziert. Dieser kann absolut oder relativ zum aktuellen Verzeichnis angegeben werden.¹

class java.io.File
implements Serializable, Comparable

Wir können ein File-Objekt durch fünf Konstruktoren erzeugen:

File( String pathname ) Erzeugt ein File-Objekt mit komplettem Pfadnamen, zum Beispiel »d:\dali\die_anpassung_der_begierde«.

File( String|File parent, String child ) Pfadname und Dateiname sind getrennt.

File( URI uri ) Fragt von uri den Pfadnamen (uri.getPath()) und erzeugt ein neues File-Objekt. Ist uri null, folgt eine NullPointerException, ist die URI falsch formuliert, gibt es eine IllegalArgumentException.

URL-Objekte aus einem File-Objekt

Da es bei URL-Objekten recht häufig vorkommt, dass eine Datei die Basis ist, wurde die Methode toURL() der Klasse File aufgenommen. Es muss nur ein File-Objekt erzeugt werden, und anschließend erzeugt toURL() ein URL-Objekt, welches das Protokoll »file« trägt und eine absolute Pfadangabe zur Datei beziehungsweise zum Verzeichnis enthält. So liefert new File("C:/Programme/").toURL() das URL-Objekt mit der URL file:/C:/Programme/.

Da diese Methode das Trennzeichen für die Pfade beachtet, ist die Angabe demnach auch passend für die Plattform. Ein Verzeichnis endet passend mit dem Pfadtrenner.

class java.io.File
implements Serializable, Comparable

URL toURL() throws MalformedURLException Liefert ein URL-Objekt vom File-Objekt.

URI toURI() Liefert ein URI-Objekt vom File-Objekt.

12.1.2 Dateieigenschaften und -attribute

Eine Datei oder ein Verzeichnis besitzt zahlreiche Eigenschaften, die sich mit Anfragemethoden auslesen lassen. In einigen wenigen Fällen lassen sich die Attribute auch ändern.

boolean canRead() true, wenn wir lesend zugreifen dürfen

boolean canWrite() true, wenn wir schreibend zugreifen dürfen

boolean exists() true, wenn das File-Objekt existiert

String getAbsolutePath() Liefert den absoluten Pfad. Ist das Objekt kein absoluter Pfadname, so wird ein String aus aktuellem Verzeichnis, Separator-Zeichen und Dateinamen des Objekts verknüpft.

String getCanonicalPath() throws IOException File getCanonicalFile() throws IOException Gibt den Pfadnamen des Dateiobjekts zurück, der keine relativen Pfadangaben mehr enthält. Kann im Gegensatz zu den anderen Pfadfunktionen eine IOException aufrufen, da mitunter verbotene Dateizugriffe erfolgen.

String getName() Gibt Dateinamen zurück.

String getParent() Gibt Pfadnamen des Vorgängers zurück.

String getPath() Gibt Pfadnamen zurück.

boolean isAbsolute() true, wenn der Pfad in der systemabhängigen Notation absolut ist

boolean isDirectory() Gibt true zurück, wenn es sich um ein Verzeichnis handelt.

boolean isFile() true, wenn es sich um eine »normale« Datei handelt (kein Verzeichnis und keine Datei, die vom zugrunde liegenden Betriebssystem als besonders markiert wird; Blockdateien, Links unter Unix). In Java können nur normale Dateien erzeugt werden.

long length() Gibt die Länge der Datei in Bytes zurück oder 0L, wenn die Datei nicht existiert oder es sich um ein Verzeichnis handelt.

if ( f.getPath().equals(f.getParent()) )
 // File f ist root

try
{
  System.out.println( new File("C:/./WasNDas//..\\Programme").getCanonicalFile() );
}
catch ( IOException e ) { }

Änderungsdatum einer Datei

Eine Datei besitzt unter jedem Dateisystem nicht nur Attribute wie Größe und Rechte, sondern verwaltet auch das Datum der letzten Änderung. Letzteres nennt sich Zeitstempel. Die File-Klasse besitzt zum Abfragen dieser Zeit die Methode lastModified(). Mit der Methode setLastModified() lässt sich die Zeit auch setzen. Dabei bleibt es etwas verwunderlich, warum lastModified() nicht als veraltet ausgezeichnet ist und zu getLastModified() geworden ist, wo doch nun die passende Funktion zum Setzen der Namensgebung genügt.

class java.io.File
implements Serializable, Comparable

long lastModified() Liefert den Zeitpunkt, an dem die Datei zum letzten Mal geändert wurde. Die Zeit wird in Millisekunden ab dem 1. Januar 1970, 00:00:00 GMT gemessen. Die Methode liefert null, wenn die Datei nicht existiert oder ein Ein- beziehungsweise Ausgabefehler auftritt.

boolean setLastModified( long time ) Setzt die Zeit, an dem die Datei zuletzt geändert wurde. Die Zeit ist wiederum in Millisekunden seit dem 1. Januar 1970 angegeben. Ist das Argument negativ, dann wird eine IllegalArgumentException ausgeworfen.

Die Methode setLastModified() ändert - wenn möglich - den Zeitstempel, und ein anschließender Aufruf von lastModified() liefert die gesetzte Zeit - womöglich gerundet - zurück. Die Funktion ist von vielfachem Nutzen, aber sicherheitsbedenklich. Denn ein Programm kann den Dateiinhalt ändern und den Zeitstempel dazu. Auf den ersten Blick ist nicht mehr sichtbar, dass eine Veränderung der Datei vorgenommen wurde. Doch die Funktion ist von größerem Nutzen bei der Programmerstellung, wo Quellcodedateien etwa mit Objektdateien verbunden sind. Nur über einen Zeitstempel ist eine einigermaßen intelligente Projektdateiverwaltung möglich.

Dateien berühren, neue Dateien anlegen

Unter dem Unix-System gibt es das Shell-Kommando touch, welches wir in einer einfachen Variante in Java umsetzen wollen. Das Programm berührt (engl. touch) eine Datei, indem der Zeitstempel auf das aktuelle Datum gesetzt wird. Da es mit setLastModified() einfach ist, das Zeitattribut zu setzen, muss die Datei nicht geöffnet, das erste Byte gelesen und gleich wieder geschrieben werden. Wie beim Kommando touch soll unser Java-Programm über alle auf der Kommandozeile übergebenen Dateien gehen und sie berühren. Falls eine Datei nicht existiert, soll sie kurzerhand angelegt werden. Gibt setLastModified() den Wahrheitswert false zurück, so wissen wir, dass die Operation fehlschlug, und geben eine Informationsmeldung aus.

Listing 12.1 Touch.java

import java.io.*;
public class Touch
{
  public static void main( String args[] ) throws IOException
  {
    for ( int i = 0; i < args.length; i++ )
    {
      File f = new File( args[i] );
      if ( f.exists() )
      {
        if ( f.setLastModified( System.currentTimeMillis() ) )
          System.out.println( "touched " + args[i] );
        else
          System.out.println( "touch failed on " + args[i] );
      }
      else
      {
        f.createNewFile();
        System.out.println( "create new file " + args[i] );
      }
    }
  }
}

class java.io.File
implements Serializable, Comparable

boolean createNewFile() throws IOException Legt eine neue Datei, wenn noch keine existiert.

static File createTempFile( String prefix, String suffix ) throws IOException Legt eine neue Datei im temporären Verzeichnis an. Das Verzeichnis ist etwa /temp unter Unix oder c:/temp unter Windows. Der Dateiname setzt sich zusammen aus einem benutzerdefinierten Präfix, einer Zufallsfolge und einem Suffix.

static File createTempFile( String prefix, String suffix, File directory ) throws IOException Legt eine neue Datei im gewünschten Verzeichnis an. Der Dateiname setzt sich zusammen aus einem benutzerdefinierten Präfix, einer Zufallsfolge und einem Suffix.

12.1.3 Sicherheitsprüfung

Wir müssen uns bewusst sein, dass verschiedene Methoden, unter der Bedingung, dass ein Security-Manager die Dateioperationen überwacht, eine SecurityException auslösen können. Security-Manager kommen beispielsweise bei Applets zum Zuge. Folgende Methoden sind Kandidaten für eine SecurityException: exists(), canWrite(), canRead(), canWrite(), isDirectory(), lastModified(), length(), mkdir(), mkdirs(), list(), delete() und renameFile().

12.1.4 Umbenennen und Verzeichnisse anlegen

class java.io.File
implements Serializable, Comparable

boolean mkdir() Legt das Unterverzeichnis an.

boolean mkdirs() Legt das Unterverzeichnis inklusive weiterer Verzeichnisse an.

boolean renameTo( File d ) Benennt die Datei in den Namen um, der durch das File-Objekt d gegeben ist. Ging alles gut, wird true zurückgegeben.

12.1.5 Die Wurzel aller Verzeichnisse

Die statische Methode listRoots() gibt ein Feld von File-Objekten zurück, die eine Auflistung der Wurzeln (engl. root) von Dateisystemen enthält. Dies macht es einfach, Programme zu schreiben, die etwa über dem Dateisystem eine Suche ausführen. Da es unter Unix nur eine Wurzel gibt, ist der Rückgabewert von File.listRoots() immer »/« - ein anderes Root gibt es nicht. Unter Windows wird es aber zu einem richtigen Feld, da es mehrere Wurzeln für die Partitionen oder logischen Laufwerke gibt. Die Wurzeln tragen Namen wie »A:« oder »Z:«. Dynamisch eingebundene Laufwerke, die etwa unter Unix mit »mount« integriert werden, oder Wechselfestplatten werden mit berücksichtigt. Die Liste wird immer dann aufgebaut, wenn listRoots() aufgerufen wird. Komplizierter ist es, wenn entfernte Dateibäume mittels NFS oder SMB eingebunden sind. Denn dann kommt es darauf an, ob das zuständige Programm eine Verbindung noch aktiv hält oder nicht. Denn nach einer abgelaufenen Zeit ohne Zugriff wird das Verzeichnis wieder aus der Liste genommen. Dies ist aber wieder sehr plattformabhängig.

class java.io.File
implements Serializable, Comparable

static File[] listRoots() Liefert die verfügbaren Wurzeln der Dateisysteme oder null, falls diese nicht festgestellt werden können. Jedes File-Objekt beschreibt eine Dateiwurzel. Es ist gewährleistet, dass alle kanonischen Pfadnamen mit einer der Wurzeln beginnen. Wurzeln, für die der SecurityManager den Zugriff verweigert, werden nicht aufgeführt. Das Feld ist leer, falls es keine Dateisystem-Wurzeln gibt.

Liste der Wurzeln ausgeben

Im folgenden Beispiel wird ein Programm vorgestellt, das mit listRoots() eine Liste der verfügbaren Wurzeln ausgibt. Dabei berücksichtigt das Programm, ob auf das Gerät eine Zugriffsmöglichkeit besteht. Unter Windows ist etwa ein Diskettenlaufwerk eingebunden, aber wenn keine Diskette im Schacht ist, ist das Gerät nicht bereit. Das Diskettenlaufwerk taucht in der Liste auf, aber exists() liefert false.

Listing 12.2 ListRoots.java

import java.io.*;
public class ListRoots
{
  public static void main( String args[] )
  {
    File list[] = File.listRoots();
    
    for ( int i = 0; i < list.length; i++ )
      System.out.println( list[i].getPath() + " ist " +
                         (list[i].exists() ? "" : "nicht ") +
                          "bereit" );
  }
}

Bei der Ausgabe mit System.out.println() entspricht root.getPath() einem root.toString(). Demnach könnte das Programm etwas abgekürzt werden, etwa mit root + " XYZ". Da aber nicht unbedingt klar ist, dass toString() auf getPath() verweist, schreiben wir getPath() direkt.

12.1.6 Verzeichnisse listen und Dateien filtern

Um eine Verzeichnisanzeige oder einen Dateiauswahldialog zu programmieren, benötigen wir eine Liste von Dateien, die in einem Verzeichnis liegen. Ein Verzeichnis kann reine Dateien oder auch wieder Unterverzeichnisse besitzen. Die list()- und listFiles()-Funktionen der Klasse File geben ein Feld von Zeichenketten mit Dateien und Verzeichnissen beziehungsweise ein Feld von File-Objekten mit den beinhalteten Elementen zurück.

class java.io.File
implements Serializable, Comparable

String[] list() Gibt eine Liste der Dateien zurück. Diese enthält weder ».« noch »..«.

File[] listFiles() Gibt eine Liste der Dateien als File-Objekte zurück.

String entries[] = new File(".").list();
System.out.println( Arrays.asList(entries) );

Die einfache Funktion list() liefert dabei nur relative Pfade, also einfach den Dateinamen oder den Verzeichnisnamen. Den absoluten Namen zu einer Dateiquelle müssen wir also erst zusammensetzen. Praktischer ist da schon die Methode listFiles(), da wir hier komplette File-Objekte bekommen, die ihre ganze Pfadangabe schon kennen. Wir können den Pfad mit getName() erfragen.

Dateien nach Kriterien filtern mit FilenameFilter und FileFilter

Sollen aus einer Liste von Dateien einige mit bestimmten Eigenschaften (zum Beispiel der Endung) herausgenommen werden, so müssen wir dies nicht selbst programmieren. Schlüssel hierzu ist die Schnittstelle FilenameFilter und FileFilter. Wenn wir etwas später den grafischen Dateiselektor kennen lernen, so können wir dort auch den FilenameFilter einsetzen. Leider ließ der Fehlerteufel seine Finger nicht aus dem Spiel und der FilenameFilter funktioniert nicht, da der FileSelector fehlerhaft ist.²

Ein Filter filtert aus den Dateinamen diejenigen heraus, die einem gesetzten Kriterium genügen. Eine Möglichkeit ist, nach den Endungen zu separieren. Doch auch komplexere Selektionen sind denkbar; so kann in die Datei hineingesehen werden, ob sie beispielsweise bestimmte Informationen am Dateianfang enthält. Besonders für Macintosh-Benutzer ist dies wichtig zu wissen, denn dort sind die Dateien nicht nach Endungen sortiert. Die Information liegt in den Dateien selbst. Windows versucht uns auch diese Dateitypen vorzuenthalten, aber von dieser Kennung hängt alles ab. Wer die Endung einer Grafikdatei schon einmal umbenannt hat, der weiß, warum Grafikprogramme aufgerufen werden. Von den Endungen hängt also sehr viel ab.

class java.io.File
implements Serializable, Comparable

public String[] list( FilenameFilter filter ) Wie list(), nur filtert ein spezielles FilenameFilter-Objekt Objekte heraus.

public File[] listFiles( FilenameFilter filter ) Wie listFiles(), nur filtert ein spezielles FilenameFilter-Objekt Objekte heraus.

public File[] listFiles( FileFilter filter ) Wie list(), nur filtert ein spezielles FileFilter-Objekt bestimmte Objekte heraus.

interface java.io.FileFilter

boolean accept( File pathname ) Liefert true, wenn der Pfad in die Liste aufgenommen werden soll.

interface java.io.FilenameFilter

boolean accept( File dir, String name ) Testet, ob die Datei name im Verzeichnis dir in der Liste auftreten soll. Gibt true zurück, wenn dies der Fall ist.

Eine Filter-Klasse implementiert die Funktion accept() von FilenameFilter so, dass alle von accept() angenommenen Dateien den Rückgabewert true liefern.

class FileFilter implements FilenameFilter
{
  public boolean accept( File f, String s )
  {
    return s.toLowerCase().endsWith( ".txt" );
  }
}

Nun kann list() mit dem FilenameFilter aufgerufen werden. Wir bekommen eine Liste mit Dateinamen, die wir in einer Schleife einfach ausgeben. An dieser Stelle merken wir schon, dass wir nur für FilenameFilter eine neue Klasse schreiben müssen. Hier bietet sich wieder eine innere Klasse an.

String a[] = entries.list( new FilenameFilter() {
  public boolean accept( File d, String name ) {
    return d.isDir();
  } } );

Die einfache Implementierung von list() mit FilenameFilter

Die Methode list() holt zunächst ein Feld von Dateinamen ein. Nun wird jede Datei mittels der accept()-Methode geprüft und in eine interne ArrayList übernommen. Nach dem Testen jeder Datei wird das Array mit ((String[])(v.toArray(new String[0])) in ein Feld von Strings kopiert. Bei listFiles() steht anstelle von String dann File.

Dateien aus dem aktuellen Verzeichnis filtern

Wir können somit ein einfaches Verzeichnisprogramm programmieren, indem wir die Funktionen von getProperty() und list() zusammenfügen. Zusätzlich wollen wir nur Dateien mit der Endung .txt angezeigt bekommen.

Listing 12.3 Dir.java

import java.io.*;
class TxtFilenameFilter implements FilenameFilter
{
  public boolean accept( File f, String s )
  {
    return s.toLowerCase().endsWith(".txt");
  }
}
public class Dir
{
  public static void main( String args[] )
  {
    File userdir = new File( System.getProperty("user.dir") );
    System.out.println( userdir );
    String entries[] = userdir.list( new TxtFilenameFilter() );
    for ( int i = 0; i < entries.length; i++ )
      System.out.println( entries[i] );
  }
}

12.1.7 Dateien und Verzeichnisse löschen

Mit Hilfe der Funktion delete() auf einem File-Objekt lässt sich eine Datei oder ein Verzeichnis entfernen. Diese Methode löscht wirklich! Sie ist nicht so zu verstehen, dass sie true liefert, falls die Datei potenziell gelöscht werden kann. Konnte die Laufzeitumgebung delete() nicht ausführen, so sollte die Rückgabe false sein. Ein zu löschendes Verzeichnis muss leer sein, andernfalls kann das Verzeichnis nicht gelöscht werden. Unsere unten stehende Implementierung geht dieses Problem so an, dass es rekursiv die Unterverzeichnisse löscht.

class java.io.File
implements Serializable, Comparable

boolean delete() Löscht die Datei oder das leere Verzeichnis.

void deleteOnExit() Löscht die Datei/das Verzeichnis, wenn die virtuelle Maschine korrekt beendet wird. Einmal vorgeschlagen, kann das Löschen nicht mehr rückgängig gemacht werden.

Die delete()-Funktion funktioniert auf File-Objekten, die Dateien und auch Verzeichnisse repräsentieren. Doch sind Verzeichnisse nicht leer, so wird delete() nicht auch noch alle Dateien in diesem Verzeichnis inklusive aller Unterverzeichnisse löschen. Das muss von Hand gemacht werden, lässt sich aber in wenigen Programmcodezeilen rekursiv umsetzen. Eine Funktion deleteTree() soll einen Baum inklusive Unterverzeichnisse löschen. list() liefert ein Feld aller Elemente in dem Unterverzeichnis, und falls ein Element wiederum ein Verzeichnis ist, wird wieder deleteTree() auf diesem aufgerufen.

Listing 12.4 DeleteTree.java

import java.io.*;
public class DeleteTree
{
  public static void deleteTree( File path )
  {
    File files[] = path.listFiles();
    for ( int i = 0; i < files.length; i++ )
    {
      if ( files[i].isDirectory() )
        deleteTree( files[i] );
      files[i].delete();
    }
    path.delete();
  }
  public static void deleteTree( String path )
  {
    deleteTree( new File(path) );
  }
  public static void main( String[] args )
  {
    deleteTree( "c:/temp/Kopie von kai" );
  }
}

12.1.8 Implementierungsmöglichkeiten für die Klasse File

Wir sollten für die Klasse File noch einmal festhalten, dass sie lediglich ein Verzeichnis oder eine Datei im Verzeichnissystem repräsentiert, jedoch keine Möglichkeit bietet, auf die Daten selbst zuzugreifen. Es ist ebenso offensichtlich, dass wir mit den plattformunabhängigen Eigenschaften von Java spätestens bei Zugriffen auf das Dateisystem nicht mehr weiter kommen. Wenn zum Beispiel eine Datei gelöscht werden soll oder wir eine Liste von Dateien im Verzeichhnis erbitten, sind Betriebssystemfunktionen mit von der Partie. Diese sind dann nativ programmiert. Es bieten sich zwei Möglichkeiten für die Implementierung an.

Jedes Betriebssystem implementiert folglich eine konkrete Unterklasse für FileSystem, die dann von File genutzt werden kann. File ist dann völlig frei von nativen Methoden und leitet alles an das FileSystem-Objekt weiter, das intern mit folgender Zeile angelegt wird:

static private FileSystem fs = FileSystem.getFileSystem();

Dann ergibt sich zum Beispiel für den Zugriff auf die Länge einer Datei:

public long length() {
  SecurityManager security = System.getSecurityManager();
  if ( security != null )
    security.checkRead( path );
   return fs.getLength( this );
}

Wenn wir dies noch einmal mit dem ersten Weg vergleichen, dann finden wir in der File-Implementierung von Kaffe etwa Folgendes:

public class File implements Serializable, Comparable
{
  static {
    System.loadLibrary( "io" );
  }
  public long length() {
    checkReadAccess();
    return length0();
  }
  native private long length0();
}

Die native Methode ist selbstverständlich privat, denn sonst gäbe es ja keine Sicherheitsprüfung. Oft trägt sie die Endung 0, so dass eine Unterscheidung einfach ist.

Um das Geheimnis um die native Methode length0() zu lüften und einen Eindruck von nativen Methoden zu vermitteln, gönnen wir uns einen Blick auf die Implementierung:

jlong
java_io_File_length0( struct Hjava_io_File* this )
{
  struct stat buf;
  char str[MAXPATHLEN];
  int r;
  stringJava2CBuf( unhand(this)->path, str, sizeof(str) );
  r = KSTAT( str, &buf );
  if ( r != 0 )
    return (jlong)0;
  return (jlong)buf.st_size;
}

Der Aufruf stringJava2CBuf() konvertiert die Unicode-Zeichenfolge in eine gültige C-Zeichenkette, die mit einem Null-Byte abschließt. Es folgt der Aufruf einer ANSI-Bibliotheksfunktion, die noch über KSTAT gekapselt ist. Der Datentyp jlong ist kein C(++)-Datentyp, sondern in der javaspezifischen Header-Datei definiert.

Wenn wir uns etwas später mit dem Zugriff über Stream-Klassen beschäftigen, dann benutzt auch diese Klasse native Methoden und eine abstrakte Repräsentation eines Dateideskriptors.

12.1.9 Verzeichnisse nach Dateien rekursiv durchsuchen

Im vorausgehenden Kapitel haben wir einige Datenstrukturen kennen gelernt, unter anderem Vector und Stack. Wir wollen damit ein Programm formulieren, welches rekursiv die Verzeichnisse durchläuft und nach Dateien durchsucht. Die Vector-Klasse dient dazu, die Dateien zu speichern, und mit dem Stack merken wir uns die jeweiligen Verzeichnisse (Tiefensuche), in die wir absteigen. Anders als bei DeleteTree nutzt diese Implementierung also keine Rekursion.

Listing 12.5 FileFinder.java

import java.io.*;
import java.util.*;
public class FileFinder
{
  public static void main( String args[] )
  {
    String suffix[] = { ".gif", ".jpg", ".tif" } ;
    String userDir = System.getProperty("user.dir"),
           path = new File(userDir).getParent();
    System.out.println( "Looking in path:" + path );
    FileFinder ff = new FileFinder( path, suffix );
    ff.print();
  }
  public void print()
  {
    int noFiles = files.size();
    if ( noFiles == 0 ) {
      System.out.println( "No files found." );
      return;
    }
    System.out.print( "Found " + noFiles + " file" );
    if ( noFiles != 1 )
      System.out.println( "s." );
    else
      System.out.println( "." );
    for ( int i = 0; i < noFiles; i++ )
    {
      String path;
      path = ((File)files.elementAt(i)).getAbsolutePath();
      System.out.println( path );
    }
  }
  public FileFinder( String start, String extensions[] )
  {
    files = new Vector();
    Stack dirs = new Stack();
    File startdir = new File(start);
    if ( startdir.isDirectory() )
      dirs.push( new File(start) );
    while ( dirs.size() > 0 )
    {
      File dirFiles = (File) dirs.pop();
      String s[] = dirFiles.list();
      if ( s != null )
      {
        for ( int i = 0; i < s.length; i++ ) {
          File file = new File( dirFiles.getAbsolutePath()
                                + File.separator + s[i] );
          if ( file.isDirectory() )
            dirs.push( file );
          else
          if ( match(s[i], extensions) )
            files.addElement( file );
        }
      }
    }
  }
  private static boolean match( String s1, String suffixes[] )
  {
    for ( int i = 0; i < suffixes.length; i++)
    if ( s1.length() >= suffixes[i].length() &&
         s1.substring(s1.length() - suffixes[i].length(),
                      s1.length()).equalsIgnoreCase(suffixes[i]))
      return true;
    return false;
  }
  private Vector files;
}

¹ Ein Wunder, warum das nicht großgeschrieben ist! Dabei ist die Variable public static final char, also eine waschechte Konstante.

² Obwohl die Funktionalität dokumentiert ist, findet sich unter der Bug-Nummer 4031440 kurz: »The main issue is that support for FilenameFilter in the FileDialog class was never implemented on any platform - it's not that there's a bug which needs to be fixed, but that there's no code to run nor was the design ever evaluated to see if it *could* be implemented on our target platforms«.