How to check if string contains substring in java

In Java application development, working with strings is a fundamental task, as strings are used in almost every program. One of the common challenges when manipulating strings is checking if a String contains a substring in Java. This operation can be key in situations such as keyword searching, validating user input, or processing large amounts of text. Knowing how to perform this check efficiently can significantly improve the quality and performance of your code.

This type of verification is useful in a variety of use cases: from filtering content and performing database lookups to implementing functionality in web forms, where you need to check whether a text string includes a specific pattern. For example, you might need to check whether an email address contains the “@” symbol, or whether a URL contains certain parameters.

In this article, we’ll teach you how to check if a string contains a substring in Java, exploring different methods you can use to do so effectively. You’ll see practical examples using the most common methods, such as contains(), indexOf(), and matches(), and learn which one is best suited for your specific case. By the end, you’ll have the tools you need to tackle any task involving searching for substrings in your Java projects.

What is a substring in Java?

In Java, a substring is any sequence of characters that is contained within a larger text string. That is, a substring is a portion of a string, which can be extracted using different methods of the String class in Java. The ability to work with substrings is essential when you want to perform searches or manipulate content within text strings.

To check if a string contains a substring in Java, it is first important to understand how to identify and work with substrings. A typical example is searching for a word or pattern within a longer text. For example, you might want to check if the text in a form contains a specific keyword, or if an input string is well-formed. In this context, knowing how to handle substrings in Java is essential.

In Java, substrings can be extracted from a string using the substring() method, which takes two parameters: the start (inclusive) index and the end (exclusive) index of the substring within the original string.

Simple example of substring in Java

Suppose we have the following string: “Welcome to Java”. If we want to extract the word “Java”, this would be our substring. Here’s how to get it using the substring() method:

Code example:

String texto = "Bienvenidos a Java";
String subcadena = texto.substring(17);  // 'Java' es la subcadena
System.out.println(subcadena);  // Devuelve "Java"

In this example, the substring(17) method starts extracting characters from index 17, which is where the word “Java” starts in the original text. The result is the substring “Java”.

This concept of substring is essential when you need to check if a string contains a substring in Java. Using methods like contains(), you can check if a specific substring exists within a given string. Thus, understanding how substrings work allows you to perform searches and text manipulations more efficiently.

Methods to check if a String contains a substring in Java

In Java, there are several ways to check if a string contains a substring. Depending on your needs, you can opt for simple methods or more complex ones that allow you to perform more specific or precise searches. Below, we explore three of the most commonly used methods: contains(), indexOf(), and matches(). Each has its advantages and recommended use cases.

Using the contains() method

The contains() method of the String class is one of the simplest and most efficient ways to check if a string contains a substring. This method returns a boolean value (true or false) depending on whether the substring is present in the string.

• Description: contains() checks whether the original string contains the sequence of characters passed as an argument. It is case sensitive, meaning that a search for “java” will not match “Java”.
• Syntax:

boolean contains(CharSequence sequence)

• Code example:

String texto = "Welcome to Java";
boolean contieneJava = texto.contains("Java");
System.out.println(contieneJava);  // Returns true

• Advantages:
  • Simple and direct: This is the easiest method to use when you need to check if a string contains a substring.
  • Efficiency: It is fast for small strings or simple searches.

If your task is limited to checking for the presence of a substring without needing to obtain its position or perform more complex searches, contains() is the ideal method for you.

Checking substrings with indexOf() in Java

The indexOf() method returns the position of the first occurrence of a substring in a string. If the substring is not found, it returns -1. This method is useful when you not only need to know whether a substring exists, but also its location within the string.

• Description: indexOf() searches for the substring and returns the index where the substring starts within the original string. If not found, -1 is returned.
• Syntax:

int indexOf(String str)

• Code example:

String texto = "Welcome to Java";
int index = texto.indexOf("Java");
boolean contieneJava = index != -1;
System.out.println(contieneJava);  // Returns true

• Advantages and disadvantages:
  • Advantages:
    • Provides greater control over substring placement.
    • This is useful if you need to perform additional operations on the index (for example, extracting a portion of the string from the substring).
  • disadvantages:
    • It requires you to manually check if the index is different from -1, which makes the code slightly longer and more complex than with contains().

This method is ideal when you need to not only check for the presence of a substring, but also perform additional action based on its position within the string.

Using matches() with regular expressions

The matches() method allows you to check if a string matches a pattern given by a regular expression (regex). This method is more advanced and useful when you need to perform complex searches that are not limited to a simple substring.

• Description: matches() matches the string against a regular expression and returns true if the string matches the specified pattern. This makes it a great choice when you need to match more complex patterns (such as matches for multiple terms or sequences of characters).
• Syntax:

boolean matches(String regex)

• Code example:

String texto = "Welcome to Java";
boolean contieneJava = texto.matches(".*Java.*");
System.out.println(contieneJava);  // Returns true

• Advantages and disadvantages:
  • Advantages:
    • Powerful: Allows you to perform advanced searches and complex patterns using regular expressions.
    • Flexible: This is useful when the substring you are searching for follows a pattern and is not a fixed string (e.g. validating emails, phone numbers, etc.).
  • disadvantages:
    • Unnecessary overhead for simple substring searches, as regular expressions can be slower and more complex than the above methods.
    • Requires regex knowledge: If you are not familiar with regular expressions, this method may be more difficult to implement correctly.

While matches() is powerful, it is best suited for complex searches and not simple substring checks. If you only need to check if a string contains a substring, the contains() or indexOf() methods are often better choices.

Comparison of methods to check substrings in Java: Which one to use?

When it comes to checking whether a string contains a substring in Java, each of the methods we’ve discussed—contains(), indexOf(), and matches()—has unique features that make it better suited for certain scenarios. Depending on your specific needs, choosing the right method can improve the clarity and efficiency of your code.

Below is a comparison table summarizing the main differences between these three methods, including their advantages and disadvantages. This table will help you make an informed decision about which method to use based on your requirements.

Which method should I use?

• If you just need to check if a string contains a substring in a simple and efficient manner, contains() is generally the best choice.
• If you need to know the position of the substring within the string or perform additional action based on the location, indexOf() will be more suitable.
• If you are working with complex patterns or need matching that involves regular expressions, such as text format validation, matches() will be the right choice, although it is more cumbersome for simple tasks.

Select the method that best suits the complexity of your task and the efficiency you require for your project.

Common mistakes when checking substrings in Java

When working with substring checking in Java, there are some common mistakes that developers often make, especially when it comes to string manipulation. These mistakes can affect the accuracy of the results or even lead to unexpected behavior in your program. Below, we address two of the most common problems and how to fix them.

Issue 1: Ignoring case (case sensitivity)

One of the most common mistakes when checking if a string contains a substring in Java is not taking into account case differences. Java is case-sensitive by default, which means that the contains() method will not be able to find a substring if there are differences in capitalization. For example, searching for the substring “java” in a string like “Welcome to Java” will return false if case is not handled properly.

• Solution: To avoid this problem, you can use the equalsIgnoreCase() method to compare the strings in a case-insensitive manner, or you can convert both strings to lowercase (or uppercase) before performing the contains() check.
• Code example:

String texto = "Welcome to Java";
boolean contieneJava = texto.toLowerCase().contains("java".toLowerCase());
System.out.println(contieneJava);  // Returns true

In this case, toLowerCase() converts both the original text and the substring to lowercase before performing the comparison, ensuring that the search is not case-sensitive.

Issue 2: Not checking if substring is empty or null

Another common mistake when checking if a string contains a substring is not checking if the substring you are looking for is null or empty. If you try to check for a null or empty substring in a string, you might get unexpected results or even runtime errors.

• Solution: You should always check if the substring is valid before performing the verification. You can do this with a simple condition that checks if the substring is not null and not empty.
• Code example:

String texto = "Welcome to Java";
String subcadena = "Java";

if (subcadena != null && !subcadena.isEmpty() && texto.contains(subcadena)) {
    System.out.println("The substring is found in the text.");
} else {
    System.out.println("Substring not found or invalid.");
}

In this case, the condition ensures that the substring is neither null nor empty before performing the check with contains(). This prevents potential errors and ensures that the code runs correctly even if it is passed empty or null inputs.

Conclusion

In this article, we’ve explored several ways to check if a string contains a substring in Java. We’ve learned about three key methods: contains(), indexOf(), and matches(). Each of these methods has its advantages and disadvantages, and choosing one over the other depends on the complexity of the task you’re performing.

References

• String (Java Platform SE 8)