Expand Authors Top

If you have a few years of experience in the Java ecosystem and you’d like to share that with the community, have a look at our Contribution Guidelines.

Expanded Audience – Frontegg – Security (partner)
announcement - icon User management is very complex, when implemented properly. No surprise here.

Not having to roll all of that out manually, but instead integrating a mature, fully-fledged solution - yeah, that makes a lot of sense.
That's basically what Frontegg is - User Management for your application. It's focused on making your app scalable, secure and enjoyable for your users.
From signup to authentication, it supports simple scenarios all the way to complex and custom application logic.

Have a look:

>> Elegant User Management, Tailor-made for B2B SaaS

Java Top

Get started with Spring 5 and Spring Boot 2, through the Learn Spring course:


1. Overview

In this short tutorial, we're going to cover in-depth how to check if a string ends with a certain pattern in Java.

First, we'll start by considering solutions using core Java. Then, we're going to showcase how to accomplish the same thing using external libraries.

2. Using the String Class

Simply put, String provides multiple convenient options to verify if a given string ends with a particular substring.

Let's take a closer look at each option.

2.1. String#endsWith Method

This method is introduced typically for this purpose. It offers the most straightforward way to check if a String object ends with another string.

So, let's see it in action:

public static boolean usingStringEndsWithMethod(String text, String suffix) {
    if (text == null || suffix == null) {
        return false;
    return text.endsWith(suffix);

Please note that endsWith is not null-safe. So, we need first to make sure that text and suffix are not null to avoid NullPointerException.

2.2. String#matches Method

matches is another great method that we can use to achieve our objective. It simply checks whether or not a string matches a given regular expression.

Basically, all we need to do is specify the regex that works properly for our use case:

public static boolean usingStringMatchesMethod(String text, String suffix) {
    if (text == null || suffix == null) {
        return false;
    String regex = ".*" + suffix + "$";
    return text.matches(regex);

As we can see, we used a regular expression that matches suffix at the end ($) of our string text. Then, we passed the regex to the matches method.

2.3. String#regionMatches Method

Similarly, we can use regionMatches method to address our central question. It returns true if a string part matches exactly the specified string, and it returns false otherwise.

Now, let's illustrate this with an example:

public static boolean usingStringRegionMatchesMethod(String text, String suffix) {
    if (text == null || suffix == null) {
        return false;
    int toffset = text.length() - suffix.length();
    return text.regionMatches(toffset, suffix, 0, suffix.length());

toffset denotes the starting offset of the subregion in our string. So, in order to check if text ends with the specified suffix, toffset should be equal to the length of text minus the length of suffix.

3. Using the Pattern Class

Alternatively, we can use the Pattern class to compile a regular expression that checks if a string ends with a pattern.

Without further ado, let's reuse the same regex we specified in the previous section:

public static boolean usingPatternClass(String text, String suffix) {
    if (text == null || suffix == null) {
        return false;
    Pattern pattern = Pattern.compile(".*" + suffix + "$");
    return pattern.matcher(text).find();

As shown above, Pattern compiles the previous regex, which denotes the end of a string, and attempts to match it against our string text.

4. Using Apache Commons Lang

Apache Commons Lang provides a set of ready-to-use utility classes for string manipulation. Among these classes, we find StringUtils.

This utility class comes with an interesting method called endsWith. It checks if a sequence of characters ends with a suffix in a null-safe manner.

Now, let's exemplify the use of the StringUtils.endsWith method:

public static boolean usingApacheCommonsLang(String text, String suffix) {
    return StringUtils.endsWith(text, suffix);

5. Conclusion

In this article, we’ve explored different ways to check if a string ends with a particular pattern.

First, we saw a couple of ways to achieve this using built-in Java classes. Then, we explained how to do the same thing using the Apache Commons Lang library.

As always, the code used in this article can be found over on GitHub.

Java bottom

Get started with Spring 5 and Spring Boot 2, through the Learn Spring course:

Generic footer banner
Inline Feedbacks
View all comments
Comments are closed on this article!