Java String contains() Method with Examples

This article will examine the contains() method, an inbuilt method of the String class in the Java programming language. Let’s jump into the topic without beating around the bush by examining its necessity, advantages, and syntax.

Finally, we will look at a couple of codes that illustrate using the contains() method. To understand and master the concept quickly, I recommend you practice each code in the article, make some modifications, and experiment with the code to cover different scenarios.

What does the contains() method In Java do?

The contains() method is an inbuilt method in the JavaString class. It looks for the occurrence of a sequence of characters in the given string and returns true if the sequence of char values is found in this string; otherwise, the contains() method returns false.

When do we use the contains() method in Java?

The contains() method in Java is handy when checking if a specific String contains a particular substring. For example, If you’re going to test if the String “FirstCode” contains the substring “Code”, the contains() method is helpful in such a situation.

Implementation of the contains() method

Before we look at the syntax and examples of the contains(), let us take a peek behind the curtains at the working of the contains method:

public boolean contains(CharSequence sequence)
{
   return indexOf(sequence.toString()) > -1;
}

In the above-shown code, the conversion of CharSequence to a String takes place, and then the indexOf() method is invoked. The method indexOf() returns zero or a higher number if it finds the String; if not, -1 is returned. Therefore, after execution, the contains() method returns true if the sequence of char values exists; if it does not exist, it returns false.

What is the syntax of the contains() method in Java?

The syntax of calling the contains() method of the String class in Java is shown below:

String1.contains(String2)

In the above-shown syntax, the contains() method checks if the sequence of characters in “String2” is present in String2. It will essentially check if String2 is a subset of String1.

Now that we know the theory of the contains() method let us implement this knowledge in some examples:

class Main
{  
    public static void main(String args[])
    {  
        String name="FirstCode";  
        System.out.println(name.contains("First"));  
        System.out.println(name.contains("Code"));  
        System.out.println(name.contains("Gopi"));  
    }
}

Output:

True
True
False

In the above program, the substrings “First” and “Code” are part of the string “FirstCode”; hence, the compiler prints True, but the string “Gopi” is not a substring of “FirstCode,” which is why the compiler prints False.

Is the contains() method case-sensitive in Java?

This method is case-sensitive, meaning it will not ignore the case; it will search for the exact substring you passed in the parameter list. Here is an example:

public class Main 
{  
    public static void main(String[] args) 
    {  
        System.out.println("FirstCode".contains("First"));  
        System.out.println("FirstCode".contains("first"));  
    }  
}

Output:

True
False

Using the contains() method along with control flow statements

To increase the versatility of the contains() methods, we can pair them with some control flow statements to perform specific tasks. Here is an example where we use the contains() method in an If-Else statement:

public class Main 
{   
    public static void main(String[] args) 
    {          
        String str = "FirstCode";        
        if(str.contains("First")) 
        {System.out.println("This string contains the substring 'First'");}
        else{System.out.println("Substring not found");}     
    }  
}

Output:

This string contains the substring ‘First’

NULL pointer exception while using the contain() method

While using the contains() method, the compiler will throw a NullPointerException if you pass null as the parameter. This is because the contains() method checks if the element is present in the collection. If the element is null, it cannot be present in the collection so that the method will throw a NullPointerException.

Here is an example:

public class Main   
{   
    public static void main(String argvs[])  
    {  
        String str = "FirstCode";  
        if(str.contains(null))  
        {System.out.println("Substring found");}  
        else{System.out.println("Substring not found");}  
    }  
}

Output:

Conclusion

The contains() method in Java’s String class offers a convenient solution for efficiently checking the existence of a substring within a given string. We discussed its importance, syntax, and implementation details, emphasizing its case-sensitive behavior and showcasing its integration with control flow statements for enhanced versatility.

Developers are encouraged to master their understanding by experimenting with the provided code snippets. Through hands-on practice, one can grasp the practical applications of the contains() method, making it a valuable asset for substring checks in Java programming.