Obtaining the Last Path Segment of a URI in Java

Last updated: March 14, 2024

Written by: Diego Martin

Reviewed by: Michal Aibin

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Distributed systems often come with complex challenges such as service-to-service communication, state management, asynchronous messaging, security, and more.

Dapr (Distributed Application Runtime) provides a set of APIs and building blocks to address these challenges, abstracting away infrastructure so we can focus on business logic.

In this tutorial, we'll focus on Dapr's pub/sub API for message brokering. Using its Spring Boot integration, we'll simplify the creation of a loosely coupled, portable, and easily testable pub/sub messaging system:

>> Flexible Pub/Sub Messaging With Spring Boot and Dapr

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.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.