How to combine paths in Java?

Combining path instances in Java

In Java, the java.nio.file.Path typically serves as the chosen interface for managing file system paths. It specializes in combining scalable paths using the resolve() method.

Multiple path segments

When you're patching together more than two path segments, don't hesitate to chain resolve:

// Creating a "totally-not-suspicious" music stash
Path basePath = Paths.get("/home/user");
Path combinedPath = basePath.resolve("downloads").resolve("music");


The combinedPath will be well concealed at /home/user/downloads/music.

Channeling some C# vibes

In case you miss having C#'s Path.Combine in Java, File class is here to cheer you up:

// Here's a "can't believe it's not Path.Combine" in Java
public static String combine(String path1, String path2) {
  File file1 = new File(path1);
  File file2 = new File(file1, path2);
  return file2.getPath();
}


Make use of it for binding two strings into a legitimate path.

Dealing with special situations and considerations

While Java has robust built-in utilities for path combination, certain contexts might necessitate different strategies.

Time for Apache Commons IO's cameo

When you need a more uniform performance across various environments, Apache Commons IO's FilenameUtils.concat() is your go-to guy:

// Take a detour to Apache county
String combined = FilenameUtils.concat("/home/user", "downloads/music");


Raising valuable library code

When working with library code, abstain from mentioning Paths.get() explicitly for greater flexibility and compatibility- Accept Path instances as parameters instead.

Reversing paths with relativize

Path.relativize() works as the antithesis of resolve, computing the relative path between two paths.

// Performing operation "Path.Etract"
Path basePath = Paths.get("/home/user/photos");
Path fullPath = Paths.get("/home/user/photos/2020/paris.jpg");
Path relativePath = basePath.relativize(fullPath); // "2020/paris.jpg" extracted successfully!


When you're attempting to deduce the difference between two paths, this method is rather handy.

All hail platform independence

Paths.get() is platform-independent, automatically adopting the system’s File.separator for maintaining consistency across different operating systems.

Manual path handling in Java

If the default methods are less than satisfactory, you can always whip up a custom combine() method for creating your own "pathway":

// Who needs GPS anyway?
public static Path combine(Path... paths) {
  Path result = paths[0];
  for (int i = 1; i < paths.length; i++) {
    result = result.resolve(paths[i]);
  }
  return result;
}


This function effortlessly handles an array of Path objects, chaining them together into a whole path.

Keep an eye out for edge cases

Stay guarded against potential edge cases; for instance, if you pass an absolute path to resolve, the base path is ignored:

// Here's why you don't use absolute paths for pranks
Path basePath = Paths.get("/home/user");
Path combinedPath = basePath.resolve("/etc"); 
// Spoiler: it outputs "/etc", not "/home/user/etc"


Acknowledge these quirks to prevent surprising path results.

Efficiency vs encapsulation

Prefer using resolve for efficiency rather than employing basic string concatenation. However, for better encapsulation, wrap your path logic in a method, abstracting away the complexity.