Unveiling Alternatives to String.contains in Java with Examples

Java, one of the most versatile and extensively employed programming languages, boasts a rich array of string manipulation methods. Among these, String.contains often serves as the go-to for simple string-searching tasks. However, it may not always cater to diverse developer needs. To enhance our problem-solving capabilities and expand our toolset, let's explore alternative techniques. This article unveils four noteworthy alternatives to String.contains: String.indexOf, String.matches, Pattern and Matcher classes, and StringUtils.contains from Apache Commons Lang, complete with illustrative examples.

String.indexOf

a core member of the standard Java library. This method operates by returning the index of the first occurrence of a specified substring within a string, or -1 if the substring is not found. Let's illustrate with an example:

String str = "Welcome to Java";
if (str.indexOf("Java") != -1) {
    System.out.println("'Java' found!");
} else {
    System.out.println("'Java' not found");
}        

In this example, String.indexOf identifies that "Java" indeed exists within our string. While String.indexOf is simple and efficient, its inability to support regular expressions or provide extra information such as multiple occurrences or exact positions constrains its utility.

String.matches

another feature from the standard Java library, shines when complex pattern matching is necessary. This method checks whether the input string matches a specified regular expression. Here's how you can use it:

String str = "Welcome to Java";
if (str.matches(".*Java.*")) {
    System.out.println("'Java' found!");
} else {
    System.out.println("'Java' not found");
}        

Note that String.matches evaluates the entire string, requiring the ".*" prefix and suffix to search for a substring. While extremely flexible, this method could be slower and potentially overkill for simple substring searches.

The Pattern and Matcher

these classes offer an exceptional solution. With these classes, you can locate multiple matches, form groups, and determine the exact positions of matches, providing robust options for intricate pattern searching tasks. Here's an example:

import java.util.regex.Pattern;
import java.util.regex.Matcher;

String str = "Welcome to Java, Java is great!";
Pattern pattern = Pattern.compile("Java");
Matcher matcher = pattern.matcher(str);
while (matcher.find()) {
    System.out.println("'Java' found at index: " + matcher.start());
}        

In this snippet, the Pattern and Matcher classes find multiple occurrences of "Java" and provide their exact positions. However, these classes require more complexity in understanding and usage, potentially rendering them excessive for simple tasks.

StringUtils.contains from the Apache Commons Lang library

This function introduces additional null safety by returning false if either the input string or the search string is null. An example usage could look like this:

import org.apache.commons.lang3.StringUtils;

String str = "Welcome to Java";
if (StringUtils.contains(str, "Java")) {
    System.out.println("'Java' found!");
} else {
    System.out.println("'Java' not found");
}        

While this method adds extra safety and comes bundled with many other useful string utilities, it requires an external library dependency and does not support regular expressions.

Conclusion

while String.contains is a dependable tool, alternatives such as String.indexOf, String.matches, Pattern and Matcher classes, and StringUtils.contains from Apache Commons Lang often better align with specific string manipulation requirements. Each method carries its strengths and limitations; understanding these nuances empowers developers to select the best tool for the job. In the dynamic world of Java, our flexibility to choose the ideal tool is what fuels the creation of efficient, understandable, and impactful code.