Apache Commons IO - Kurzanleitung

Die Apache Commons IO-Bibliothek bietet verschiedene Dienstprogrammklassen für allgemeine Vorgänge für Datei-E / A, die eine Vielzahl von Anwendungsfällen abdecken. Es hilft, das Schreiben von Boilerplate-Code zu vermeiden.

Die Apache Commons IO-Bibliothek bietet Klassen für die folgenden Kategorien:

Dienstprogrammklassen

Diese Klassen, die unter sind org.apache.commons.ioPaket, bietet Datei- und Zeichenfolgenvergleich. Es folgen einige Beispiele.

• IOUtils- Bietet Dienstprogrammmethoden zum Lesen, Schreiben und Kopieren von Dateien. Die Methoden arbeiten mit InputStream, OutputStream, Reader und Writer.

• FilenameUtils- Bietet eine Methode zum Arbeiten mit Dateinamen ohne Verwendung von File Object. Es funktioniert auf ähnliche Weise auf verschiedenen Betriebssystemen.

• FileUtils - Bietet eine Methode zum Bearbeiten von Dateien wie Verschieben, Öffnen, Überprüfen der Existenz, Lesen von Dateien usw. Diese Methoden verwenden File Object.

• IOCase - Bietet eine Methode zur Manipulation und zum Vergleich von Zeichenfolgen.

• FileSystemUtils - Bietet eine Methode zum Abrufen des freien Speicherplatzes auf einem Laufwerk.

• LineIterator - Bietet eine flexible Möglichkeit, mit einer zeilenbasierten Datei zu arbeiten.

Filterklassen

Filterklassen, die sich unter dem Paket org.apache.commons.io.filefilter befinden, bieten Methoden zum Filtern von Dateien basierend auf logischen Kriterien anstelle von auf Zeichenfolgen basierenden langwierigen Vergleichen. Es folgen einige Beispiele.

• NameFileFilter - Filtert Dateinamen nach einem Namen.

• WildcardFileFilter - Filtert Dateien mit den mitgelieferten Platzhaltern.

• SuffixFileFilter- Filtert Dateien basierend auf dem Suffix. Dies wird zum Abrufen aller Dateien eines bestimmten Typs verwendet.

• PrefixFileFilter - Filtert Dateien basierend auf dem Präfix.

• OrFileFilter- Bietet bedingte ODER-Logik für eine Liste von Dateifiltern. Gibt true zurück, wenn Filter in der Liste true zurückgeben. Andernfalls wird false zurückgegeben.

• AndFileFilter- Bietet Bedingungen und Logik für eine Liste von Dateifiltern. Gibt false zurück, wenn Filter in der Liste false zurückgeben. Andernfalls wird true zurückgegeben.

Dateimonitor-Klassen

Dateimonitor-Klassen, die unter sind org.apache.commons.io.monitorPaket, bietet Kontrolle zum Verfolgen von Änderungen in einer bestimmten Datei oder einem bestimmten Ordner und ermöglicht entsprechende Aktionen für die Änderungen. Es folgen einige Beispiele.

• FileEntry- Gibt den Status einer Datei oder eines Verzeichnisses an. Dateiattribute zu einem bestimmten Zeitpunkt.

• FileAlterationObserver - Stellt den Status von Dateien unterhalb eines Stammverzeichnisses dar, überprüft das Dateisystem und benachrichtigt Listener über Ereignisse zum Erstellen, Ändern oder Löschen.

• FileAlterationMonitor - Stellt einen Thread dar, der einen Überwachungsthread erzeugt, der in einem bestimmten Intervall einen registrierten FileAlterationObserver auslöst.

Komparatorklassen

Dateimonitorklassen unter org.apache.commons.io.comparator Paket ermöglichen das einfache Vergleichen und Sortieren von Dateien und Verzeichnissen.

• NameFileComparator - Vergleichen Sie die Namen zweier Dateien.

• SizeFileComparator - Vergleichen Sie die Größe von zwei Dateien.

• LastModifiedFileComparator - Vergleichen Sie die letzten Änderungsdaten von zwei Dateien.

Stream-Klassen

Es gibt mehrere Implementierungen von InputStream unter dem Paket org.apache.commons.io.input und von OutputStream unter dem Paket org.apache.commons.io.output, um nützliche Aufgaben für Streams auszuführen. Es folgen einige Beispiele.

• NullOutputStream - Absorbiert alle fehlerhaft gesendeten Daten.

• TeeOutputStream - Sendet die Ausgabe an zwei Streams.

• ByteArrayOutputStream - Schnellere Version der JDK-Klasse.

• CountingOutputStream - Zählt die Anzahl der Bytes, die durch den Stream geleitet werden.

• ProxyOutputStream - Ändert die Aufrufe zum Proxy-Stream.

• LockableFileWriter - Ein FileWriter zum Erstellen von Sperrdateien und zum einfachen Behandeln von Thread-übergreifenden Dateisperren.

In diesem Kapitel erfahren Sie mehr über die Einrichtung der lokalen Umgebung von Apache Commons IO und das Einrichten des Pfads von Commons IO für Windows 2000 / XP, Windows 95/98 / ME usw. Wir werden auch einige beliebte Java-Editoren und kennenlernen Herunterladen des Commons IO-Archivs.

Einrichtung der lokalen Umgebung

Wenn Sie weiterhin bereit sind, Ihre Umgebung für die Programmiersprache Java einzurichten, finden Sie in diesem Abschnitt Anleitungen zum Herunterladen und Einrichten von Java auf Ihrem Computer. Befolgen Sie die unten aufgeführten Schritte, um die Umgebung einzurichten.

Java SE kann unter dem Link kostenlos heruntergeladen werden https://www.oracle.comSie laden also eine Version herunter, die auf Ihrem Betriebssystem basiert.

Befolgen Sie die Anweisungen, um Java herunterzuladen und auszuführen .exeum Java auf Ihrem Computer zu installieren. Sobald Sie Java auf Ihrem Computer installiert haben, müssen Sie Umgebungsvariablen so einstellen, dass sie auf korrekte Installationsverzeichnisse verweisen.

Pfad für Windows 2000 / XP

Lassen Sie uns verstehen, wie Sie den Pfad für Windows 2000 / XP einrichten. Wir gehen davon aus, dass Sie Java installiert habenc:\Program Files\java\jdk Verzeichnis.

• Klicken Sie mit der rechten Maustaste auf "Arbeitsplatz" und wählen Sie "Eigenschaften".

• Klicken Sie auf der Registerkarte "Erweitert" auf die Schaltfläche "Umgebungsvariablen".

• Ändern Sie nun die Variable 'Path' so, dass sie auch den Pfad zur ausführbaren Java-Datei enthält. Wenn der Pfad derzeit auf "C: \ WINDOWS \ SYSTEM32" festgelegt ist, ändern Sie Ihren Pfad in "Lesen"'C:\WINDOWS\SYSTEM32;c:\Program Files\java\jdk\bin'.

Pfad für Windows 95/98 / ME

Lassen Sie uns verstehen, wie Sie den Pfad für Windows 95/98 / ME einrichten. Wir gehen davon aus, dass Sie Java installiert habenc:\Program Files\java\jdk Verzeichnis.

• Bearbeiten Sie die Datei 'C: \ autoexec.bat' und fügen Sie am Ende die folgende Zeile hinzu: 'SET PATH =% PATH%; C: \ Programme \ java \ jdk \ bin'

Pfad für Linux, UNIX, Solaris, FreeBSD

Die Umgebungsvariable PATH sollte so eingestellt werden, dass sie darauf hinweist, wo die Java-Binärdateien installiert wurden. Informationen hierzu finden Sie in Ihrer Shell-Dokumentation.

Wenn Sie beispielsweise bash als Shell verwenden, fügen Sie die folgende Zeile am Ende Ihrer '.bashrc: export PATH = / path / to / java: $ PATH' hinzu.

Beliebte Java-Editoren

Zum Schreiben Ihrer Java-Programme benötigen Sie einen Texteditor. Es gibt viele hoch entwickelte IDEs auf dem Markt. Im Moment können Sie jedoch eine der folgenden Möglichkeiten in Betracht ziehen:

• Notepad - Auf einem Windows-Computer können Sie einen einfachen Texteditor wie Notepad (für dieses Lernprogramm empfohlen) und TextPad verwenden.

• Netbeans - Es ist eine Java-IDE, die Open Source und kostenlos ist und von heruntergeladen werden kann https://www.netbeans.org/index.html.

• Eclipse - Es ist auch eine Java-IDE, die von der Open-Source-Community von eclipse entwickelt wurde und von heruntergeladen werden kann https://www.eclipse.org/.

Laden Sie das Common IO Archive herunter

Laden Sie die neueste Version der Apache Common IO-JAR-Datei von commons-io-2.6- bin.zip herunter, die unter download_io.cgi verfügbar ist. Zum Zeitpunkt des Schreibens dieses Tutorials haben wir commons-io-2.6-bin.zip heruntergeladen und kopiert es in C: \> Apache Ordner.

Betriebssystem	Archivname
Windows	commons-io-2.6-bin.zip
Linux	commons-io-2.6-bin.tar.gz
Mac	commons-io-2.6-bin.tar.gz

Apache Common IO-Umgebung

Stellen Sie die APACHE_HOMEUmgebungsvariable, die auf den Speicherort des Basisverzeichnisses verweist, in dem Apache jar auf Ihrem Computer gespeichert ist. Angenommen, wir haben commons-io-2.6-bin.zip im Apache-Ordner auf verschiedenen Betriebssystemen wie folgt extrahiert.

Betriebssystem	Ausgabe
Windows	Setzen Sie die Umgebungsvariable APACHE_HOME auf C: \ Apache
Linux	export APACHE_HOME = / usr / local / Apache
Mac	export APACHE_HOME = / Library / Apache

Setzen Sie die Variable CLASSPATH

Stellen Sie die CLASSPATHUmgebungsvariable, die auf den Common IO-JAR-Speicherort verweist. Angenommen, Sie haben commons-io-2.6-bin.zip wie folgt im Apache-Ordner auf verschiedenen Betriebssystemen gespeichert.

Betriebssystem	Ausgabe
Windows	Setzen Sie die Umgebungsvariable CLASSPATH auf% CLASSPATH%;% APACHE_HOME% \ commons-io-2.6.jar;.;
Linux	export CLASSPATH = $ CLASSPATH: $ APACHE_HOME / commons-io-2.6.jar:.
Mac	export CLASSPATH = $ CLASSPATH: $ APACHE_HOME / commons-io-2.6.jar:.

IOUtils bieten Dienstprogrammmethoden zum Lesen, Schreiben und Kopieren von Dateien. Die Methoden arbeiten mit InputStream, OutputStream, Reader und Writer.

Klassenerklärung

Es folgt die Erklärung für org.apache.commons.io.IOUtils Klasse -

public class IOUtils
   extends Object

Merkmale von IOUtils

Die Funktionen von IOUtils sind unten angegeben -

• Bietet statische Dienstprogrammmethoden für Eingabe- / Ausgabeoperationen.

• toXXX () - liest Daten aus einem Stream.

• write () - schreibt Daten in einen Stream.

• copy () - kopiert alle Daten in einen Stream in einen anderen Stream.

• contentEquals - Vergleichen Sie den Inhalt von zwei Streams.

Beispiel für die IOUtils-Klasse

Hier ist die Eingabedatei, die wir analysieren müssen -

Welcome to TutorialsPoint. Simply Easy Learning.

IOTester.java

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import org.apache.commons.io.IOUtils;
public class IOTester {
   public static void main(String[] args) {
      try {
         //Using BufferedReader
         readUsingTraditionalWay();
         //Using IOUtils
         readUsingIOUtils();
      } catch(IOException e) {
         System.out.println(e.getMessage());
      }
   }
   //reading a file using buffered reader line by line
   public static void readUsingTraditionalWay() throws IOException {
      try(BufferedReader bufferReader = new BufferedReader( new InputStreamReader(
      new FileInputStream("input.txt") ) )) {
         String line;
         while( ( line = bufferReader.readLine() ) != null ) {
            System.out.println( line );
         }
      }
   }
   //reading a file using IOUtils in one go
   public static void readUsingIOUtils() throws  IOException {
      try(InputStream in = new FileInputStream("input.txt")) {
         System.out.println( IOUtils.toString( in , "UTF-8") );
      }
   }
}

Ausgabe

Es wird das folgende Ergebnis gedruckt -

Welcome to TutorialsPoint. Simply Easy Learning.
Welcome to TutorialsPoint. Simply Easy Learning.

FileUtils bieten eine Methode zum Bearbeiten von Dateien wie Verschieben, Öffnen, Überprüfen der Existenz, Lesen von Dateien usw. Diese Methoden verwenden File Object.

Klassenerklärung

Es folgt die Deklaration für die Klasse org.apache.commons.io.FileUtils -

public class FileUtils
   extends Object

Funktionen von FileUtils

Die Funktionen von FileUtils sind unten angegeben -

• Methoden zum Schreiben in eine Datei.

• Methoden zum Lesen aus einer Datei.

• Methoden zum Erstellen eines Verzeichnisses mit übergeordneten Verzeichnissen.

• Methoden zum Kopieren von Dateien und Verzeichnissen.

• Methoden zum Löschen von Dateien und Verzeichnissen.

• Methoden zum Konvertieren in und von einer URL.

• Methoden zum Auflisten von Dateien und Verzeichnissen nach Filter und Erweiterung.

• Methoden zum Vergleichen des Dateiinhalts.

• Methoden zum Ablegen des letzten Änderungsdatums.

• Methoden zur Berechnung einer Prüfsumme.

Beispiel für die FileUtils-Klasse

Hier ist die Eingabedatei, die wir analysieren müssen -

Welcome to TutorialsPoint. Simply Easy Learning.

IOTester.java

import java.io.File;
import java.io.IOException;
import java.nio.charset.Charset;
import org.apache.commons.io.FileUtils;
public class IOTester {
   public static void main(String[] args) {
      try {
         //Using FileUtils
         usingFileUtils();
      } catch(IOException e) {
         System.out.println(e.getMessage());
      }
   }
   public static void usingFileUtils() throws IOException {
      //get the file object
      File file = FileUtils.getFile("input.txt");
      //get the temp directory
      File tmpDir = FileUtils.getTempDirectory();
      System.out.println(tmpDir.getName());
      //copy file to temp directory
      FileUtils.copyFileToDirectory(file, tmpDir);
      //create a new file
      File newTempFile = FileUtils.getFile(tmpDir, file.getName());
      //get the content
      String data = FileUtils.readFileToString(newTempFile, Charset.defaultCharset());
      //print the content
      System.out.println(data);
   }
}

Ausgabe

Die Ausgabe wird unten erwähnt -

Temp
Welcome to TutorialsPoint. Simply Easy Learning.

FilenameUtils bieten eine Methode zum Arbeiten mit Dateinamen ohne Verwendung von File Object. Es funktioniert auf ähnliche Weise auf verschiedenen Betriebssystemen. Diese Klasse löst Probleme beim Wechsel von einem Windows-basierten Entwicklungscomputer zu einem Unix-basierten Produktionscomputer.

Klassenerklärung

Es folgt die Erklärung für org.apache.commons.io.FilenameUtils Klasse -

public class FilenameUtils
   extends Object

Funktionen von FileNameUtils

Diese Klasse definiert sechs Komponenten innerhalb eines Dateinamens. Betrachten Sie einen Beispielstandort alsC:\dev\project\file.txt. Dann sind die Komponenten wie folgt:

• Präfix - C: \

• Relativer Pfad - dev \ project \

• Absoluter Pfad - C: \ dev \ project \

• Name - file.txt

• Basisname - Datei

• Erweiterung - txt

Fügen Sie dem Dateinamen ein Trennzeichen hinzu, um ein Verzeichnis zu identifizieren.

Beispiel für die FilenameUtils-Klasse

Das Beispiel der FilenameUtils-Klasse ist unten angegeben -

IOTester.java

import java.io.IOException;
import org.apache.commons.io.FilenameUtils;
public class IOTester {
   public static void main(String[] args) {
      try {
         //Using FilenameUtils
         usingFilenameUtils();
      } catch(IOException e) {
         System.out.println(e.getMessage());
      }
   }
   public static void usingFilenameUtils() throws IOException {
      String path = "C:\\dev\\project\\file.txt";
      System.out.println("Full Path: " +FilenameUtils.getFullPath(path));
      System.out.println("Relative Path: " +FilenameUtils.getPath(path));
      System.out.println("Prefix: " +FilenameUtils.getPrefix(path));
      System.out.println("Extension: " + FilenameUtils.getExtension(path));
      System.out.println("Base: " + FilenameUtils.getBaseName(path));
      System.out.println("Name: " + FilenameUtils.getName(path));
      String filename = "C:/commons/io/../lang/project.xml";
      System.out.println("Normalized Path: " + FilenameUtils.normalize(filename));
   }
}

Ausgabe

Die Ausgabe ist unten angegeben -

Full Path: C:\dev\project\
Relative Path: dev\project\
Prefix: C:\
Extension: txt
Base: file
Name: file.txt
Normalized Path: C:\commons\lang\project.xml

FileSystemUtils bieten eine Methode zum Abrufen des freien Speicherplatzes auf einem Laufwerk.

Klassenerklärung

Es folgt die Erklärung für org.apache.commons.io.FileSystemUtils Klasse -

public class FileSystemUtils
   extends Object

Beispiel für die FileSystemUtils-Klasse

Im Folgenden finden Sie ein Beispiel für die FileSystemUtils-Klasse -

IOTester.java

import java.io.IOException;
import org.apache.commons.io.FileSystemUtils;
public class IOTester {
   public static void main(String[] args) {
      try {
         System.out.println("Free Space " + FileSystemUtils.freeSpaceKb("C:/") + " Bytes");
      } catch(IOException e) {
         System.out.println(e.getMessage());
      }
   }
}

Ausgabe

Unten ist die Ausgabe angegeben -

Free Space 61355640 kb

Aufzählung der IO-Groß- / Kleinschreibung. Unterschiedliche Betriebssysteme haben unterschiedliche Regeln für die Groß- und Kleinschreibung von Dateinamen. Beispielsweise unterscheidet Windows bei der Benennung von Dateien nicht zwischen Groß- und Kleinschreibung, während bei Unix zwischen Groß- und Kleinschreibung unterschieden wird. IOCase erfasst diesen Unterschied und bietet eine Aufzählung, um zu steuern, wie Dateinamenvergleiche durchgeführt werden sollen. Es bietet auch Methoden zur Verwendung der Aufzählung zum Durchführen von Vergleichen.

Aufzählungserklärung

Es folgt die Deklaration für org.apache.commons.io.IOCase Enum -

public enum IOCase
   extends Enum<IOCase> implements Serializable

Beispiel für IOCase Enum

Ein Beispiel für IOCase Enum ist unten angegeben -

IOTester.java

import java.io.IOException;
import org.apache.commons.io.IOCase;
public class IOTester {
   public static void main(String[] args) {
      try {
         usingIOCase();
      } catch(IOException e) {
         System.out.println(e.getMessage());
      }
   }
   public static void usingIOCase() throws IOException {
      String text = "Welcome to TutorialsPoint. Simply Easy Learning.";
      String text1 = "WELCOME TO TUTORIALSPOINT. SIMPLY EASY LEARNING.";
      System.out.println("Ends with Learning (case sensitive): " + IOCase.SENSITIVE.checkEndsWith(text1, "Learning."));
      System.out.println("Ends with Learning (case insensitive): " + IOCase.INSENSITIVE.checkEndsWith(text1, "Learning."));
      System.out.println("Equality Check (case sensitive): " + IOCase.SENSITIVE.checkEquals(text, text1));
      System.out.println("Equality Check (case insensitive): " + IOCase.INSENSITIVE.checkEquals(text, text1));
   }
}

Ausgabe

Es wird das folgende Ergebnis gedruckt -

Ends with Learning (case sensitive): false
Ends with Learning (case insensitive): true
Equality Check (case sensitive): false
Equality Check (case insensitive): true

LineIterator bietet eine flexible Möglichkeit, mit einer zeilenbasierten Datei zu arbeiten. Lassen Sie uns in diesem Kapitel etwas darüber lernen.

Klassenerklärung

Es folgt die Erklärung für org.apache.commons.io.LineIterator Klasse -

public class LineIterator
   extends Object implements Iterator<String>, Closeable

Beispiel einer LineIterator-Klasse

Hier ist die Eingabedatei, die wir analysieren müssen -

Welcome to TutorialsPoint. Simply Easy Learning.
Learn web technologies,
prepare exams,
code online,
all at one place.

IOTester.java

import java.io.File;
import java.io.IOException;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.LineIterator;
public class IOTester {
   public static void main(String[] args) {
      try {
         usingLineIterator();
      } catch(IOException e) {
         System.out.println(e.getMessage());
      }
   }
   public static void usingLineIterator() throws IOException {
      //get the file object
      File file = FileUtils.getFile("input.txt");
      try(LineIterator lineIterator = FileUtils.lineIterator(file)) {
         System.out.println("Contents of input.txt");
         while(lineIterator.hasNext()) {
            System.out.println(lineIterator.next());
         }
      }
   }
}

Ausgabe

Es wird das folgende Ergebnis gedruckt -

Contents of input.txt
Welcome to TutorialsPoint. Simply Easy Learning.
Learn web technologies,
prepare exams,
code online,
all at one place.

NameFileFilter in Commons IO filtert die Dateinamen nach einem Namen.

Klassenerklärung

Es folgt die Erklärung für org.apache.commons.io.filefilter.NameFileFilter Klasse:

public class NameFileFilter
   extends AbstractFileFilter implements Serializable

Beispiel für die NameFileFilter-Klasse

Hier ist die Eingabedatei, die wir analysieren müssen -

Welcome to TutorialsPoint. Simply Easy Learning.

Drucken wir alle Dateien und Verzeichnisse im aktuellen Verzeichnis und filtern dann eine Datei mit dem Namen Input.txt.

IOTester.java

import java.io.File;
import java.io.IOException;
import org.apache.commons.io.IOCase;
import org.apache.commons.io.filefilter.NameFileFilter;
public class IOTester {
   public static void main(String[] args) {
      try {
         usingNameFileFilter();
      } catch(IOException e) {
         System.out.println(e.getMessage());
      }
   }
   public static void usingNameFileFilter() throws IOException {
      //get the current directory
      File currentDirectory = new File(".");
      //get names of all files and directory in current directory
      String[] files = currentDirectory.list();
      System.out.println("All files and Folders.\n");
      for( int i = 0; i < files.length; i++ ) {
         System.out.println(files[i]);
      }
      System.out.println("\nFile with name input.txt\n");
      String[] acceptedNames = {"input", "input.txt"};
      String[] filesNames = currentDirectory.list( new NameFileFilter(acceptedNames, IOCase.INSENSITIVE) );
      for( int i = 0; i < filesNames.length; i++ ) {
         System.out.println(filesNames[i]);
      }
   }
}

Ausgabe

Es wird das folgende Ergebnis gedruckt -

All files and Folders.

.classpath
.project
.settings
bin
input.txt
src

File with name input.txt

input.txt

WildcardFileFilter in Commons IO filtert die Dateien mithilfe der mitgelieferten Platzhalter.

Klassenerklärung

Es folgt die Erklärung für org.apache.commons.io.filefilter.WildcardFileFilter Klasse -

public class WildcardFileFilter
   extends AbstractFileFilter implements Serializable

Beispiel für eine WildcardFileFilter-Klasse

Hier ist die Eingabedatei, die wir analysieren müssen

Welcome to TutorialsPoint. Simply Easy Learning.

Drucken wir alle Dateien und Verzeichnisse im aktuellen Verzeichnis und filtern dann eine Datei, deren Name mit endet t.

IOTester.java

import java.io.File;
import java.io.IOException;
import org.apache.commons.io.filefilter.WildcardFileFilter;
public class IOTester {
   public static void main(String[] args) {
      try {
         usingWildcardFileFilter();
      } catch(IOException e) {
         System.out.println(e.getMessage());
      }
   }
   public static void usingWildcardFileFilter() throws IOException {
      //get the current directory
      File currentDirectory = new File(".");
      //get names of all files and directory in current directory
      String[] files = currentDirectory.list();
      System.out.println("All files and Folders.\n");
      for( int i = 0; i < files.length; i++ ) {
        System.out.println(files[i]);
      }
      System.out.println("\nFile name ending with t.\n");
      String[] filesNames = currentDirectory.list( new  WildcardFileFilter("*t"));
      for( int i = 0; i < filesNames.length; i++ ) {
        System.out.println(filesNames[i]);
      }
   }
}

Ausgabe

Das folgende Ergebnis wird gedruckt.

All files and Folders.

.classpath
.project
.settings
bin
input.txt
src

File name ending with t

.project
input.txt

SuffixFileFilter filtert die Dateien, die auf dem Suffix basieren. Dies wird zum Abrufen aller Dateien eines bestimmten Typs verwendet.

Klassenerklärung

Es folgt die Erklärung für org.apache.commons.io.filefilter.SuffixFileFilter Klasse -

public class SuffixFileFilter
   extends AbstractFileFilter implements Serializable

Beispiel für die SuffixFileFilter-Klasse

Hier ist die Eingabedatei, die wir analysieren müssen -

Welcome to TutorialsPoint. Simply Easy Learning.

Drucken wir alle Dateien und Verzeichnisse im aktuellen Verzeichnis und filtern dann eine Datei mit der Erweiterung txt.

IOTester.java

import java.io.File;
import java.io.IOException;
import org.apache.commons.io.filefilter.SuffixFileFilter;
public class IOTester {
   public static void main(String[] args) {
      try {
         usingSuffixFileFilter();
      } catch(IOException e) {
         System.out.println(e.getMessage());
      }
   }
   public static void usingSuffixFileFilter() throws IOException {
      //get the current directory
      File currentDirectory = new File(".");
      //get names of all files and directory in current directory
      String[] files = currentDirectory.list();
      System.out.println("All files and Folders.\n");
      for( int i = 0; i < files.length; i++ ) {
         System.out.println(files[i]);
      }
      System.out.println("\nFile with extenstion txt\n");
      String[] filesNames = currentDirectory.list( new SuffixFileFilter("txt"));
      for( int i = 0; i < filesNames.length; i++ ) {
         System.out.println(filesNames[i]);
      }
   }
}

Ausgabe

Das folgende Ergebnis wird gedruckt.

All files and Folders.

.classpath
.project
.settings
bin
input.txt
src

File with extenstion txt

input.txt

PrefixFileFilter filtert die Dateien, die auf dem Präfix basieren.

Klassenerklärung

Es folgt die Erklärung für org.apache.commons.io.filefilter.PrefixFileFilter Klasse -

public class PrefixFileFilter
   extends AbstractFileFilter implements Serializable

Beispiel für die PrefixFileFilter-Klasse

Hier ist die Eingabedatei, die wir analysieren müssen -

Welcome to TutorialsPoint. Simply Easy Learning.

Drucken wir alle Dateien und Verzeichnisse im aktuellen Verzeichnis und filtern dann eine Datei mit einem Namen, der mit der Eingabe beginnt.

IOTester.java

import java.io.File;
import java.io.IOException;
import org.apache.commons.io.filefilter.PrefixFileFilter;
public class IOTester {
   public static void main(String[] args) {
      try {
         usingPrefixFileFilter();
      } catch(IOException e) {
         System.out.println(e.getMessage());
      }
   }
   public static void usingPrefixFileFilter() throws IOException {
      //get the current directory
      File currentDirectory = new File(".");
      //get names of all files and directory in current directory
      String[] files = currentDirectory.list();
      System.out.println("All files and Folders.\n");
      for( int i = 0; i < files.length; i++ ) {
         System.out.println(files[i]);
      }
      System.out.println("\nFile starting with input\n");
      String[] filesNames = currentDirectory.list( new PrefixFileFilter("input") );
      for( int i = 0; i < filesNames.length; i++ ) {
         System.out.println(filesNames[i]);
      }
   }
}

Ausgabe

Es wird das folgende Ergebnis gedruckt -

All files and Folders.

.classpath
.project
.settings
bin
input.txt
src

File with extenstion txt

input.txt

OrFileFilter bietet bedingte ODER-Logik für eine Liste von Dateifiltern. Es gibt true zurück, wenn Filter in der Liste true zurückgeben. Andernfalls wird false zurückgegeben.

Klassenerklärung

Es folgt die Erklärung für org.apache.commons.io.filefilter.OrFileFilter Klasse -

public class OrFileFilter
   extends AbstractFileFilter implements ConditionalFileFilter, Serializable

Beispiel einer OrFileFilter-Klasse

Hier ist die Eingabedatei, die wir analysieren müssen -

Welcome to TutorialsPoint. Simply Easy Learning.

Lassen Sie uns alle Dateien und Verzeichnisse im aktuellen Verzeichnis drucken und dann eine Datei filtern, deren Name mit beginnt. oder endet mit t.

IOTester.java

import java.io.File;
import java.io.IOException;
import org.apache.commons.io.filefilter.OrFileFilter;
import org.apache.commons.io.filefilter.PrefixFileFilter;
import org.apache.commons.io.filefilter.WildcardFileFilter;
public class IOTester {
   public static void main(String[] args) {
      try {
         usingOrFileFilter();
      } catch(IOException e) {
         System.out.println(e.getMessage());
      }
   }
   public static void usingOrFileFilter() throws IOException {
      //get the current directory
      File currentDirectory = new File(".");
      //get names of all files and directory in current directory
      String[] files = currentDirectory.list();
      System.out.println("All files and Folders.\n");
      for( int i = 0; i < files.length; i++ ) {
         System.out.println(files[i]);
      }
      System.out.println("\nFile starting with . or ends with t\n");
      String[] filesNames = currentDirectory.list( new OrFileFilter(new PrefixFileFilter("."), new WildcardFileFilter("*t")));
      for( int i = 0; i < filesNames.length; i++ ) {
         System.out.println(filesNames[i]);
      }
   }
}

Ausgabe

Das folgende Ergebnis wird gedruckt.

All files and Folders.

.classpath
.project
.settings
bin
input.txt
src

File starting with . or ends with t

.classpath
.project
.settings
input.txt

AndFileFilter bietet Bedingungen und Logik für eine Liste von Dateifiltern. Es gibt true zurück, wenn alle Filter in der Liste true zurückgeben. Andernfalls wird false zurückgegeben.

Klassenerklärung

Es folgt die Erklärung für org.apache.commons.io.filefilter.AndFileFilter Klasse -

public class AndFileFilter
   extends AbstractFileFilter implements ConditionalFileFilter, Serializable

Beispiel für die AndFileFilter-Klasse

Hier ist die Eingabedatei, die wir analysieren müssen -

Welcome to TutorialsPoint. Simply Easy Learning.

Lassen Sie uns alle Dateien und Verzeichnisse im aktuellen Verzeichnis drucken und dann eine Datei filtern, deren Name mit beginnt. und endet mit t.

IOTester.java

import java.io.File;
import java.io.IOException;
import org.apache.commons.io.filefilter.AndFileFilter;
import org.apache.commons.io.filefilter.PrefixFileFilter;
import org.apache.commons.io.filefilter.WildcardFileFilter;
public class IOTester {
   public static void main(String[] args) {
      try {
         usingAndFileFilter();
      } catch(IOException e) {
         System.out.println(e.getMessage());
      }
   }
   public static void usingAndFileFilter() throws IOException {
      //get the current directory
      File currentDirectory = new File(".");
      //get names of all files and directory in current directory
      String[] files = currentDirectory.list();
      System.out.println("All files and Folders.\n");
      for( int i = 0; i < files.length; i++ ) {
         System.out.println(files[i]);
      }
      System.out.println("\nFile starting with . and ends with t\n");
      String[] filesNames = currentDirectory.list(new AndFileFilter(
         new PrefixFileFilter("."), new WildcardFileFilter("*t")));
      for( int i = 0; i < filesNames.length; i++ ) {
        System.out.println(filesNames[i]);
      }
   }
}

Ausgabe

Das folgende Ergebnis wird gedruckt.

All files and Folders.

.classpath
.project
.settings
bin
input.txt
src

File starting with . or ends with t

.project

FileEntry gibt den Status einer Datei oder eines Verzeichnisses an. Dateiattribute zu einem bestimmten Zeitpunkt.

Klassenerklärung

Es folgt die Erklärung für org.apache.commons.io.monitor.FileEntry Klasse -

public class FileEntry
   extends Object implements Serializable

Funktionen von FileEntry

Das FileEntry-Klassenobjekt stellt zu einem bestimmten Zeitpunkt die folgenden Dateiattribute bereit.

• getName () - Dateiname.

• exist () - prüft, ob eine Datei existiert oder nicht.

• isDirectory () - prüft, ob die Datei ein Verzeichnis ist.

• lastModified () - gibt die Uhrzeit des letzten geänderten Datums an.

• listFiles () - gibt den Inhalt des Verzeichnisses an.

Beispiel für eine FileEntry-Klasse

Hier ist die Eingabedatei, die wir analysieren müssen -

Welcome to TutorialsPoint. Simply Easy Learning.

IOTester.java

import java.io.File;
import java.io.IOException;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.monitor.FileEntry;
public class IOTester {
   public static void main(String[] args) {
      try {
         usingFileEntry();
      } catch(IOException e) {
         System.out.println(e.getMessage());
      }
   }
   public static void usingFileEntry() throws IOException {
      //get the file object
      File file = FileUtils.getFile("input.txt");
      FileEntry fileEntry = new FileEntry(file);
      System.out.println("Monitored File: " + fileEntry.getFile());
      System.out.println("File name: " + fileEntry.getName());
      System.out.println("Is Directory: " + 	fileEntry.isDirectory());
   }
}

Ausgabe

Das folgende Ergebnis wird gedruckt.

Monitored File: input.txt
File name: input.txt
Is Directory: false

FileAlterationObserver repräsentiert den Status von Dateien unterhalb eines Stammverzeichnisses, überprüft das Dateisystem und benachrichtigt Listener über das Erstellen, Ändern oder Löschen von Ereignissen.

Klassenerklärung

Es folgt die Erklärung für

org.apache.commons.io.monitor.FileAlterationObserver Klasse -

public class FileAlterationObserver
   extends Object implements Serializable

Beispiel für die FileAlterationObserver-Klasse

Hier ist die Eingabedatei, die wir analysieren müssen -

Welcome to TutorialsPoint. Simply Easy Learning.

IOTester.java

import java.io.File;
import java.io.IOException;
import org.apache.commons.io.FileDeleteStrategy;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.monitor.FileAlterationListenerAdaptor;
import org.apache.commons.io.monitor.FileAlterationMonitor;
import org.apache.commons.io.monitor.FileAlterationObserver;
public class IOTester {
   public static void main(String[] args) {
      try {
         usingFileAlterationObserver();
      } catch(IOException e) {
         System.out.println(e.getMessage());
      }
   }
   public static void usingFileAlterationObserver() throws IOException {
      //get the file object
      File inputFile = FileUtils.getFile("input.txt");
      String absolutePath = inputFile.getAbsolutePath();
      String parent = absolutePath.substring(0,absolutePath.indexOf("input.txt"));
      File parentDirectory = FileUtils.getFile(parent);
      FileAlterationObserver observer = new
      FileAlterationObserver(parentDirectory);
      observer.addListener(new FileAlterationListenerAdaptor() {
         @Override
         public void onDirectoryCreate(File file) {
            System.out.println("Folder created: " + file.getName());
         }
         @Override
            public void onDirectoryDelete(File file) {
               System.out.println("Folder deleted: " + file.getName());
            }
         @Override
            public void onFileCreate(File file) {
               System.out.println("File created: " + file.getName());
            }
         @Override
            public void onFileDelete(File file) {
               Syst em.out.println("File deleted: " + file.getName());
            }
        });
       //create a monitor to check changes after every 500 ms
       FileAlterationMonitor monitor = new FileAlterationMonitor(500, observer);
       try {
          monitor.start();
         //create a new directory
         File newFolder = new File("test");
         File newFile = new File("test1");
         newFolder.mkdirs();
         Thread.sleep(1000);
         newFile.createNewFile();
         Thread.sleep(1000);
         FileDeleteStrategy.NORMAL.delete(newFolder);
         Thread.sleep(1000);
         FileDeleteStrategy.NORMAL.delete(newFile);
         Thread.sleep(1000);
         monitor.stop(10000);
      } catch(IOException e) {
         System.out.println(e.getMessage());
      } catch(InterruptedException e) {
         System.out.println(e.getMessage());
      } catch (Exception e) {
         System.out.println(e.getMessage());
      }
   }
}

Ausgabe

Das folgende Ergebnis wird gedruckt.

Folder created: test
File created: test1
Folder deleted: test
File deleted: test1

FileAlterationMonitor stellt einen Thread dar, der einen Überwachungsthread erzeugt, der in einem bestimmten Intervall einen registrierten FileAlterationObserver auslöst.

Klassenerklärung

Es folgt die Deklaration für org.apache.commons.io.monitor.FileAlterationMonitor Class -

public final class FileAlterationMonitor
   extends Object implements Runnable

Beispiel für die FileAlterationMonitor-Klasse

Here is the input file we need to parse −

Welcome to TutorialsPoint. Simply Easy Learning.

IOTester.java

import java.io.File;
import java.io.IOException;
import org.apache.commons.io.FileDeleteStrategy;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.monitor.FileAlterationListenerAdaptor;
import org.apache.commons.io.monitor.FileAlterationMonitor;
import org.apache.commons.io.monitor.FileAlterationObserver;
public class IOTester {
   public static void main(String[] args) {
      try {
         usingFileAlterationMonitor();
      } catch(IOException e) {
         System.out.println(e.getMessage());
      }
   }
   public static void usingFileAlterationMonitor() throws IOException {
      //get the file object
      File inputFile = FileUtils.getFile("input.txt");
      String absolutePath = inputFile.getAbsolutePath();
      String parent = absolutePath.substring(0,absolutePath.indexOf("input.txt"));
      File parentDirectory = FileUtils.getFile(parent);
      FileAlterationObserver observer = new
      FileAlterationObserver(parentDirectory);
      observer.addListener(new FileAlterationListenerAdaptor(){
         @Override
         public void onDirectoryCreate(File file) {
            System.out.println("Folder created: " + file.getName());
         }
         @Override
         public void onDirectoryDelete(File file) {
            System.out.println("Folder deleted: " + file.getName());
         }
         @Override
         public void onFileCreate(File file) {
            System.out.println("File created: " + file.getName());
         }
         @Override
         public void onFileDelete(File file) {
            System.out.println("File deleted: " + file.getName());
         }
      });
      //create a monitor to check changes after every 500 ms
      FileAlterationMonitor monitor = new FileAlterationMonitor(500, observer);
      try {
         monitor.start();
         //create a new directory
         File newFolder = new File("test");
         File newFile = new File("test1");
         newFolder.mkdirs();
         Thread.sleep(1000);
         newFile.createNewFile();
         Thread.sleep(1000);
         FileDeleteStrategy.NORMAL.delete(newFolder);
         Thread.sleep(1000);
         FileDeleteStrategy.NORMAL.delete(newFile);
         Thread.sleep(1000);
         monitor.stop(10000);
      } catch(IOException e) {
         System.out.println(e.getMessage());
      } catch(InterruptedException e) {
         System.out.println(e.getMessage());
      } catch (Exception e) {
         System.out.println(e.getMessage());
      }
   }
}

Output

It will print the following result.

Folder created: test
File created: test1
Folder deleted: test
File deleted: test1

NameFileComparator compare the names of two files. It can be used to sort the lists or arrays of files, using their name, either in a case-sensitive, case-insensitive or system dependent case sensitive way.

Class Declaration

Following is the declaration for

org.apache.commons.io.comparator.NameFileComparator Class −

public class NameFileComparator
   extends Object implements Serializable

Example of NameFileComparator Class

Here is the input file we need to parse −

Welcome to TutorialsPoint. Simply Easy Learning.

IOTester.java

import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import org.apache.commons.io.IOCase;
import org.apache.commons.io.comparator.NameFileComparator;
import org.apache.commons.io.filefilter.FileFileFilter;
public class IOTester {
   public static void main(String[] args) {
      try {
         usingNameFileComparator();
      } catch(IOException e) {
         System.out.println(e.getMessage());
      }
   }
   public static void usingNameFileComparator() throws IOException {
      //get the current directory
      File currentDirectory = new File(".");
      NameFileComparator comparator = new
      NameFileComparator(IOCase.INSENSITIVE);
      File[] sortedFiles = comparator.sort(currentDirectory.listFiles((FileFilter)FileFileFilter.FILE));
      System.out.println("Sorted By Name: ");
      for(File file:sortedFiles) {
         System.out.println(file.getName());
      }
   }
}

Output

It will print the following result.

Sorted By Name:
.classpath
.project
input.txt

SizeFileComparator compare the sizes of two files/directory. It can be used to sort the lists or arrays of files using their size or directories, based on their number of children.

Class Declaration

Following is the declaration for

org.apache.commons.io.comparator.SizeFileComparator Class −

public class SizeFileComparator
   extends Object implements Serializable

Example of SizeFileComparator Class

Here is the input file we need to parse −

Welcome to TutorialsPoint. Simply Easy Learning.

IOTester.java

import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import org.apache.commons.io.comparator.SizeFileComparator;
import org.apache.commons.io.filefilter.FileFileFilter;
public class IOTester {
   public static void main(String[] args) {
      try {
         usingSizeFileComparator();
      } catch(IOException e) {
         System.out.println(e.getMessage());
      }
   } 
   public static void usingSizeFileComparator() throws IOException {
      //get the current directory
      File currentDirectory = new File(".");
      SizeFileComparator comparator = new SizeFileComparator();
      File[] sortedFiles = comparator.sort(currentDirectory.listFiles((FileFilter)FileFileFilter.FILE));
      System.out.println("Sorted By Size: ");
      for(File file:sortedFiles) {
         System.out.println(file.getName() + ", size(kb) :" + file.length());
      }
   }
}

Output

It will print the following result.

Sorted By Size:
input.txt, size:124
.project, size:382
.classpath, size:441

LastModifiedFileComparator compares the last modified dates of two files/directory. It can be used to sort the lists or arrays of files/directories using their last modified dates.

Klassenerklärung

Es folgt die Erklärung für org.apache.commons.io.comparator.LastModifiedFileComparator Klasse -

public class LastModifiedFileComparator
   extends Object implements Serializable

Beispiel für die LastModifiedFileComparator-Klasse

Hier ist die Eingabedatei, die wir analysieren müssen -

Welcome to TutorialsPoint. Simply Easy Learning.

IOTester.java

import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.util.Date;
import org.apache.commons.io.comparator.LastModifiedFileComparator;
import org.apache.commons.io.filefilter.FileFileFilter;
public class IOTester {
   public static void main(String[] args) {
      try {
         usingLastModifiedFileComparator();
      } catch(IOException e) {
         System.out.println(e.getMessage());
      }
   }
   public static void usingLastModifiedFileComparator() throws IOException {
      //get the current directory
      File currentDirectory = new File(".");
      LastModifiedFileComparator comparator = new LastModifiedFileComparator();
      File[] sortedFiles = comparator.sort(currentDirectory.listFiles((FileFilter)FileFileFilter.FILE));
      System.out.println("Sorted By Last Modified date: ");
      for(File file:sortedFiles) {
         System.out.println(file.getName() + ", Modified on: " + new Date(file.lastModified()));
      }
   }
}

Ausgabe

Das folgende Ergebnis wird gedruckt.

Sorted By Last Modified date:
.project, Modified on: Thu Oct 12 19:06:45 IST 2017
.classpath, Modified on: Mon Nov 20 13:09:55 IST 2017
input.txt, Modified on: Mon Nov 20 19:27:55 IST 2017

Es ist ein InputStream-Proxy, der transparent eine Kopie aller Bytes schreibt, die aus dem Proxy-Stream in einen bestimmten OutputStream gelesen werden. Der Proxy-Eingabestream wird geschlossen, wenn die Methode close () für diesen Proxy aufgerufen wird. Es kann verwendet werden, um zwei Streams gleichzeitig zu betreiben.

Klassenerklärung

Es folgt die Erklärung für org.apache.commons.io.input.TeeInputStream Klasse -

public class TeeInputStream
   extends ProxyInputStream

Beispiel für die TeeInputStream-Klasse

In diesem Beispiel werden durch Schließen eines TeeInputStream sowohl die TeeInputStream- als auch die TeeOutputStream-Objekte geschlossen.

IOTester.java

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import org.apache.commons.io.input.TeeInputStream;
import org.apache.commons.io.output.TeeOutputStream;
public class IOTester {
   private static final String SAMPLE = "Welcome to TutorialsPoint. Simply Easy
   Learning.";
   public static void main(String[] args) {
      try {
         usingTeeInputStream();
      }catch(IOException e) {
         System.out.println(e.getMessage());
      }
   }
   public static void usingTeeInputStream() throws IOException {
      TeeInputStream teeInputStream = null;
      TeeOutputStream teeOutputStream = null;
      try {
         ByteArrayInputStream inputStream = new
         ByteArrayInputStream(SAMPLE.getBytes("US-ASCII"));
         ByteArrayOutputStream outputStream1 = new ByteArrayOutputStream();
         ByteArrayOutputStream outputStream2 = new ByteArrayOutputStream();
         teeOutputStream = new TeeOutputStream(outputStream1, outputStream2);
         teeInputStream = new TeeInputStream(inputStream, teeOutputStream, true);
         teeInputStream.read(new byte[SAMPLE.length()]);
         System.out.println("Output stream 1: " + outputStream1.toString());
         System.out.println("Output stream 2: " + outputStream2.toString());
      }catch (IOException e) {
         System.out.println(e.getMessage());
      } finally {
         //teeIn.close() closes teeIn and teeOut which in turn closes the out1 and out2.
         try {
            teeInputStream.close();
         } catch (IOException e) {
            System.out.println(e.getMessage());
         }
      }
   }
}

Ausgabe

Das folgende Ergebnis wird gedruckt.

Output stream 1: Welcome to TutorialsPoint. Simply Easy Learning.
Output stream 2: Welcome to TutorialsPoint. Simply Easy Learning.

TeeOutputStream teilt den OutputStream. Es ist nach dem Unix-Befehl 'tee' benannt. Damit kann ein Stream in zwei Streams verzweigt werden.

Klassenerklärung

Es folgt die Erklärung für org.apache.commons.io.output.TeeOutputStream Klasse -

public class TeeOutputStream
   extends ProxyOutputStream

Beispiel für die TeeOutputStream-Klasse

In diesem Beispiel akzeptiert TeeOutputStream zwei Ausgabestreams als Parameter und übergibt Daten an TeeOutputStream-Set-Daten an beide Ausgabestreams.

IOTester.java

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import org.apache.commons.io.input.TeeInputStream;
import org.apache.commons.io.output.TeeOutputStream;
public class IOTester {
   private static final String SAMPLE = "Welcome to TutorialsPoint. Simply Easy
   Learning.";
   public static void main(String[] args) {
      try {
         usingTeeInputStream();
      } catch(IOException e) {
         System.out.println(e.getMessage());
      }
   }
   public static void usingTeeInputStream() throws IOException {
      TeeInputStream teeInputStream = null;
      TeeOutputStream teeOutputStream = null;
      try {
         ByteArrayInputStream inputStream = new
         ByteArrayInputStream(SAMPLE.getBytes("US-ASCII"));
         ByteArrayOutputStream outputStream1 = new ByteArrayOutputStream();
         ByteArrayOutputStream outputStream2 = new ByteArrayOutputStream();
         teeOutputStream = new TeeOutputStream(outputStream1, outputStream2);
         teeInputStream = new TeeInputStream(inputStream, teeOutputStream, true);
         teeInputStream.read(new byte[SAMPLE.length()]);
         System.out.println("Output stream 1: " + outputStream1.toString());
         System.out.println("Output stream 2: " + outputStream2.toString());
      } catch (IOException e) {
         System.out.println(e.getMessage());
      } finally {
         //teeIn.close() closes teeIn and teeOut which in turn closes the out1 and out2.
         try {
            teeInputStream.close();
         } catch (IOException e) {
            System.out.println(e.getMessage());
         }
      }
   }
}

Ausgabe

Das folgende Ergebnis wird gedruckt.

Output stream 1: Welcome to TutorialsPoint. Simply Easy Learning.
Output stream 2: Welcome to TutorialsPoint. Simply Easy Learning.