Obtaining the Last Path Segment of a URI in Java

1. Introduction

Working with Uniform Resource Identifiers (URIs) is a common operation that is mostly used in web development and file management.

Besides, one of the most common needs is to get the last path segment out of a URL (the last segment is the last segment after the last ‘/’ character).

In this tutorial, we’ll investigate different ways to obtain the last segment of a URL.

2. Using URI Class

The java.net.URI class enables an object-oriented approach for URI parsing and manipulation. To make it easier, let’s take an example:

@Test
public void givenURL_whenUsingURIClass_thenGetLastPathSegment() throws URISyntaxException {
    URI uri = new URI("https://www.example.com/path/to/resource");
    String path = uri.getPath();
    String[] segments = path.split("/");
    String lastSegment = segments[segments.length - 1];
    assertEquals("resource", lastSegment);
}

The given method initializes a URI with a sample URL. Subsequently, the URI’s path is extracted using the getPath() method. The path is then split into segments based on the forward-slash (“/”) delimiter. The last path segment is then determined by accessing the last element of the segment array.

Finally, the test asserts that the last path segment matches the expected value, affirming that the functionality correctly extracts the intended resource from the URL.

3. Using Path Class

In Java 7, the java.nio.file.Path class provides a platform-independent representation for files and paths. Providing an effective way to extract the last segment of URI. Here’s an example:

@Test
public void givenURL_whenUsingPathClass_thenGetLastPathSegment() {
    String exampleURI = "https://www.example.com/path/to/resource";
    try {
        URI uri = new URI(exampleURI);
        String pathString = uri.getPath();
        Path path = Paths.get(pathString);
        Path lastSegment = path.getName(path.getNameCount() - 1);
        assertEquals("resource", lastSegment.toString());
    } catch (Exception e) {
        fail("Exception occurred: " + e.getMessage());
    }
}

As in the previous section, we first initialize a URI and use the getPath() method. Subsequently, we create a Path object named path from the obtained pathString. The last segment is determined using the getName() method with an index calculation. The last path segment is then converted to a string for comparison.

4. Using FilenameUtils Class

Apache Commons IO library has a FilenameUtils class that is available as a utility class for common file and path tasks. Let’s take an example:

@Test
public void givenURL_whenUsingFilenameUtilsClass_thenGetLastPathSegment() throws URISyntaxException {
    String exampleURI = "https://www.example.com/path/to/resource";
    URI uri = new URI(exampleURI);
    String path = uri.getPath();
    String lastSegment = FilenameUtils.getName(path);
    assertEquals("resource", lastSegment);
}

After extracting the path using the getPath() method, we utilize the FilenameUtils class to obtain the last path segment using the getName() method, which takes the path as a parameter.

5. Using Regular Expressions

In extracting the last path segment from a URL, regex provides an elegant solution for flexible and precise pattern definitions. Here’s an example:

@Test
public void givenURL_whenUsingRegularExpression_thenGetLastPathSegment() throws URISyntaxException {
    URI uri = new URI("https://www.example.com/path/to/resource");
    String path = uri.getPath();
    Pattern pattern = Pattern.compile(".*/(.+)");
    Matcher matcher = pattern.matcher(path);
    if (!matcher.find()) {
        fail("Regex pattern didn't match.");
    }
    String lastSegment = matcher.group(1);
    assertEquals("resource", lastSegment);
}

Here, we define a regular expression pattern “/(.+)” to capture the last segment of the URL path precisely. Leveraging the Pattern and Matcher classes, we compile and apply the regex pattern to the path string using the compile() and matcher() methods.

Moreover, a conditional check further validates the success of the regex pattern application using the find() method. Upon successful matching, the last path segment is extracted using the group(1) method from the Matcher object.

6. Conclusion

In conclusion, this tutorial explored multiple Java methods, including the URI class, Path class, FilenameUtils, and regular expressions, providing diverse approaches to extract the last path segment from a URL effectively.

As usual, the accompanying source code can be found over on GitHub.