Directory Navigation in Java | TechRepublic

We talk about how one can work with directories, sub-directories, and traverse them utilizing Java and the DirectoryStream methodology. Study extra.

Java programming tutorial.

A listing is an organizational file system construction that incorporates recordsdata and different directories. Java offers just a few methods to traverse a listing, relying on which model you might be utilizing, together with:

  1. Utilizing the listFiles() methodology of the File class
  2. Utilizing a DirectoryStream in Java 7 and onwards
  3. Utilizing the static Recordsdata.listing() methodology in Java 8 and onwards
  4. Utilizing the stroll() methodology in Java 8 and onwards

This programming tutorial will show how one can make the most of every of the above methods to navigate a listing construction in Java.

SEE: Prime Java IDEs

The File listFiles() methodology in Java

listFiles() is an occasion methodology of the class. To make use of it, all builders have to do is instantiate a brand new File object by offering a path to the constructor and after which invoke listFiles() on it. listFiles() returns an array of File objects that programmers can then iterate over to acquire extra details about particular person recordsdata and/or carry out operations on them. Here’s a primary instance that lists all the recordsdata and directories within the Home windows “C:My Paperwork” folder:

bundle com.developer;


public class ListFilesExample 
  public static void principal(String[] args) 
    // Retailer the title of recordsdata and directories
    // in an array of Recordsdata.
    // Do not forget to flee the backslash character!
    File[] recordsdata = new File("C:My Paperwork").listFiles();
    // Traverse by means of the recordsdata array
    for (File file : recordsdata) 
      // If a subdirectory is discovered,
      // print the title of the subdirectory
      if (file.isDirectory()) 
        System.out.println("Listing: " + file.getName());
        // Print the file title
        System.out.println("File: " + file.getName());

Here’s a partial itemizing of the directories and recordsdata discovered:

Listing: AAMS
Listing: Addictive Drums
Listing: Angular
Listing: angular-starter
Listing: Any Video Converter
Listing: articles
File: Avatar - Home Of Everlasting Hunt -
File: Avatar - Home Of Everlasting
File: Avatar - Legend Of The
Listing: bgfx

Recursive listing traversal in Java

Since we will check for directories, we will transfer our for loop right into a separate methodology that we will invoke recursively to listing the recordsdata of subdirectories in addition to the one offered to our methodology, as proven within the observe Java code instance:

bundle com.developer;


public class RecursiveListFilesExample 
  public static void principal(String[] args) 
    listFilesInDirectory(new File("C:My Paperwork"));
  non-public static void listFilesInDirectory(File dirPath) 
    File filesList[] = dirPath.listFiles();
    // Traverse by means of the recordsdata array
    for (File file : filesList) 
      // If a sub listing is discovered,
      // print the title of the sub listing
      if (file.isDirectory()) 
        System.out.println("Listing: " + file.getName());
        // Print the file title current in given path
        System.out.println("File: " + file.getName());

We are able to see in this system output that it’s now itemizing the recordsdata of subdirectories as nicely:

Listing: AAMS
File: AAMS V3 Guide.pdf
File: AAMS V4 Setup.exe
File: AAMS.xml
File: Licence.txt
File: Model.txt
Listing: Addictive Drums
Listing: Settings
File: MidifileDatabaseCache.dat
File: Latest.dat

SEE: Prime on-line Java programs to study Java

Utilizing DirectoryStream to loop by means of recordsdata with Java

Java 7 launched an alternative choice to listFiles() referred to as DirectoryStream. It really works nicely with the for-each assemble, permitting us to iterate over the contents of the listing as an alternative of studying every part without delay.

The instance code under reveals how one can use Java’s DirectoryStream in a way to listing the recordsdata of a listing:

public Set<String> listFilesUsingDirectoryStream(String dir) throws IOException 
  Set<String> fileSet = new HashSet<>();
  strive (DirectoryStream<Path> stream = Recordsdata.newDirectoryStream(Paths.get(dir))) 
    for (Path path : stream) 
      if (!Recordsdata.isDirectory(path)) 
  return fileSet;

Above, we let Java deal with the closing of the DirectoryStream useful resource by means of the try-with-resources assemble. We are able to make use of the static Recordsdata.isDirectory(path) methodology to filter out directories and return a Set of recordsdata within the folder.

Utilizing the static Recordsdata.listing() Technique

Java 8 launched a brand new listing() methodology in java.nio.file.Recordsdata. The listing methodology returns a lazily populated Stream of entries within the listing. As such, it’s extra environment friendly for processing massive folders. Right here is a technique that returns a Set of file names:

public Set<String> listFilesUsingFilesList(String dir) throws IOException 
  strive (Stream<Path> stream = Recordsdata.listing(Paths.get(dir))) 
    return stream
      .filter(file -> !Recordsdata.isDirectory(file))

Though the above code would possibly look much like listFiles(), it’s completely different in how builders receive every file’s path.

Once more, we created the stream utilizing the try-with-resources assemble to make sure that the listing useful resource is closed after studying the stream.

The way to stroll over listing contents in Java

The stroll() methodology returns a Stream by strolling the file tree starting with a given beginning file/listing in a depth-first method (that means that it begins with the file/listing on the biggest depth). The next program prints the complete file paths for the complete file tree beneath “C:My Paperwork”:

import java.nio.file.Recordsdata;
import java.nio.file.Path;
import java.nio.file.Paths;

class FilesWalkExample 

  public static void principal(String[] args)
    throws IOException 
    // Create a try-catch block and
    // present the listing path of native machine
    strive (Stream<Path> filepath = Recordsdata.stroll(Paths.get("C:My Paperwork"))) 
      // Print the whole path of directories and recordsdata
    // Throw an if listing would not exists 
    catch (IOException e) 
      throw new IOException("Listing not discovered!");

The primary few traces of output verify that file traversal began the best depth:

I:My DocumentsAngularmy-appnode_modulesselenium-webdriverlibtestdataproxy
I:My DocumentsAngularmy-appnode_modulesselenium-webdriverlibtestdataproxypage1.html
I:My DocumentsAngularmy-appnode_modulesselenium-webdriverlibtestdataproxypage2.html
I:My DocumentsAngularmy-appnode_modulesselenium-webdriverlibtestdataproxypage3.html
I:My DocumentsAngularmy-appnode_modulesselenium-webdriverlibtestdatareadOnlyPage.html
I:My DocumentsAngularmy-appnode_modulesselenium-webdriverlibtestdatarectangles.html
I:My DocumentsAngularmy-appnode_modulesselenium-webdriverlibtestdataRedirect.aspx
I:My DocumentsAngularmy-appnode_modulesselenium-webdriverlibtestdataRedirect.aspx.cs
I:My DocumentsAngularmy-appnode_modulesselenium-webdriverlibtestdataresultPage.html

We might embody directories as nicely by eradicating the Recordsdata::isRegularFile filter situation.

Ultimate ideas on Listing Navigation in Java

Java offers just a few methods to traverse a listing, relying on which model you might be utilizing. Though we coated the primary ones, there are different methods to navigate directories in Java, particularly for the reason that Stream API was launched in Java 8.

SEE: Maven construct automation device evaluation