One of the most common tasks in Java or any other programming language is to check whether a string contains another string or not. Java provides multiple ways to accomplish this task. You can use contains(), indexOf(), lastIndexOf(), startsWith(), and endsWith() methods to check if one string contains, starts or ends with another string in Java or not.

In this article, you'll learn about six different ways of checking if a string contains a substring in Java. Let us start with the first commonly used method — contains().

1. String.contains() Method

The first and most popular method used in Java for checking if a string contains another string is contains() from the String class. This method returns a boolean value based on whether the substring exists in the this string or not.

The contains() method searches the substring across the original string and returns true if and only if this string contains the specified sequence of character values, and false otherwise. Here is an example:

String str = "Java is a server-side programming langauge.";
str.contains("Java"); // true
str.contains("Node.js"); // false

It is important to remember that the contains() method is case-sensitive which means it treats uppercase and lowercase characters differently as shown in the below example:

"Hey, there!".contains("There"); // false
"Java 101".contains("java"); // false

For a case-insensitive search, you should convert both string and substring to lowercase as shown below:

String str = "My name is Atta!";
// case-insensitive search
str.toLowerCase().contains("ATTA".toLowerCase()); // true

Since contains() returns a boolean value, it means that you can use it directly in if statements as shown below:

String str = "My name is Atta!";
if(str.contains("Atta")) {
    System.out.println("Hey Atta 👋");
} else {
    System.out.println("Hey!");
}

// Hey Atta 👋

The contains() method throws a NullPointerException if the given substring is null. Another interesting thing to note is that contains() internally calls the indexOf() method (explains below) to check if the given sequence of character exists or not.

2. String.indexOf() Method

The indexOf() method is different than the contains() method in a way that it doesn't return a boolean value. Instead, this method returns the index of the first occurrence of the substring. If the string does not contain the given substring, it simply returns -1.

Ideally, you should use the indexOf() method to** find the index of a character** in a string. But it can also be used for substrings matching. Since contains() is implemented using the indexOf() method, they are essentially the same. It doesn't make any impact on the performance whichever method you use except that the former is more readable than the latter.

Her is an example that shows how to use the indexOf() method in Java:

String str = "Apple, Orange, & Mango are Fruits.";
str.indexOf("Apple"); // 0 (true)
str.indexOf("Mango"); // 17 (true)
str.indexOf("Banana"); // -1 (false)

Similar to contains(), the indexOf() method is also case-sensitive which means that you have to convert both strings to lowercase before performing a case-insensitive search as shown below:

String str = "iPhone X";
str.indexOf("x"); // -1 (false)
str.toLowerCase().indexOf("I".toLowerCase()); // 0 (true)

3. String.lastIndexOf() Method

The lastIndexOf() method is similar to indexOf() except that it returns the index of the last occurrence of the substring. It starts the search from the tail and returns -1 if substring not found in the string or the last position of the substring.

Here is an example that demonstrates how you can use the lastIndexOf() method to check if a string contains another substring:

String str = "iPhone X, iPhone XL";
str.lastIndexOf("iPhone"); // 10 (true)
str.lastIndexOf("Apple"); // -1 (false)

4. String.startsWith() Method

The startsWith() method can also be used for a more specific use-case where you want to check if a string starts with a given substring. This method returns a boolean value true if this string begins with the specified string, otherwise false.

The following example shows how you can use the startsWith() method to check if a string starts with the specified prefix string:

String str = "Java 101";
str.startsWith("Java"); // true
str.startsWith("101"); // false

Just like the other String class methods we have discussed above, startsWith() is also case-sensitive. So you have to lowercase both strings to perform a case-insensitive search as shown below:

String str = "Java 101";
str.startsWith("java"); // false
str.toLowerCase().startsWith("java".toLowerCase()); // true

5. String.endsWith() Method

As the name suggests, the endsWith() method is an opposite of startsWith() that returns true if and only if the string ends with a specified suffix string, and false otherwise. Here is an example:

String str = "Spring Boot & MySql";
str.endsWith("MySql"); // true
str.endsWith("Boot"); // false

endsWith() is also case-sensitive which means you need to convert both string and substring to lowercase of case-insensitive search:

String str = "Spring Boot & MySql";
str.endsWith("mysql"); // false
str.toLowerCase().endsWith("mysql".toLowerCase()); // true

6. String.matches() Method

Finally, let us look at another way of checking if a string contains a given substring by using the matches() method from the String class. Unlike other methods we discussed above, matches() accepts a regular expression as a parameter and searches the string for a match. If it finds the matches, it returns true, and false if no match is found.

Here is an example that demonstrates how you can use the matches() method to check if a string contains another substring or not:

String str = "MEAN Stack stands for MongoDB, Express, Angular, and Node";

// start with
str.matches("(?i)mean.*"); // true

// ends with
str.matches("(?i).*node"); // true

// anywhere
str.matches("(?i).*mongo.*"); // true

Here is a good article to learn more about regular expression in Java.

Conclusion

That's all folks. In this article, we have discussed various ways to check if a string contains another string in Java. You can use any of the methods above depending on your needs.

It is recommended to use indexOf() or lastIndexOf() methods only if you need the index of substring. Otherwise contains() is more readable and returns a boolean value which can be used in if statements directly.

✌️ Like this article? Follow @attacomsian on Twitter. You can also follow me on LinkedIn and DEV. Subscribe to RSS Feed.

👋 If you enjoy reading my articles and want to support me to continue creating free tutorials, Buy me a coffee (cost $5) .

Need help to launch a new product? I am available for contract work. Hire me to accomplish your business goals with engineering and design.