containsIgnoreCase() Method in Java

There are various scenarios where we need to consider case sensitivity. The ability to ignore case while comparing strings can be crucial in many applications. In this section, we will explore how to perform case-insensitive string comparisons in Java, using the power of the equalsIgnoreCase() method. We will dive into the details of the method and provide practical examples to demonstrate its usage effectively.

Using String.toLowerCase() Method

One of the easiest ways to check if a String has a substring without considering the case is to convert all the Strings to lowercase and then check for a substring.

To check for a substring, we use the contains() method, and for converting the String to lowercase, we use the toLowerCase() method.

StringComparison.java

public class StringComparison {
    public static void main(String[] args) {
        String str1 = "Life is like riding a bicycle. To keep your balance, you must keep moving. ALBERT EINSTEIN";
        // Check if str1 contains "albert" (case-insensitive)
        boolean res1 = str1.toLowerCase().contains("albert".toLowerCase());
        // Check if str1 contains "ALBERT" (case-insensitive)
        boolean res2 = str1.toLowerCase().contains("ALBERT".toLowerCase());
        // Output the results
        System.out.println("Does str1 contain 'albert'? " + res1); // Should print: Does str1 contain 'albert'? true
        System.out.println("Does str1 contain 'ALBERT'? " + res2); // Should print: Does str1 contain 'ALBERT'? true
    }
}

Output:

Result of toLowerCase: true
Result of toLowerCase: true

Using String.matches() Method

The String.matches() method is using a regex pattern to find matching strings. If we use a (?i) argument in the matches() method, we make it case-insensitive.

StringComparison.java

public class StringComparison {
    public static void main(String[] args) {
        String str1 = "Life is like riding a bicycle. To keep your balance, you must keep moving. ALBERT EINSTEIN";
        // Check if str1 contains "AlBerT" (case-insensitive) using matches and regex
        boolean res4 = str1.matches("(?i).*" + "AlBerT" + ".*");
        // Output the result
        System.out.println("Result of the matches operation is: " + res4);
    }
}

Output:

Result of the matches operation is: true

Using StringUtils.containsIgnoreCase() Method

The Apache foundation provides the apache-commons-lang.jar. It contains a collection of utility classes, one of which is the StringUtils class. The StringUtils class contains a containsIgnoreCase() method that checks if a string is a substring of another in a case-insensitive manner.

Before using the method, we need to add .jar file to the project.

Here is the dependency that need to add for Apache common lang3 in pom.xml file.

<dependency>
          <groupId>org.apache.commons</groupId>
		  <artifactId>commons-lang3</artifactId>
		  <version>3.9</version>
</dependency></p>

StringComparison.java

public class StringComparison {
    public static void main(String[] args) {
        String str1 = "Life is like riding a bicycle. To keep your balance, you must keep moving. ALBERT EINSTEIN";
        // Check if str1 contains "AlBerT" (case-insensitive) using matches and regex
        boolean res4 = str1.matches("(?i).*" + "AlBerT" + ".*");
        // Output the result
        System.out.println("Result of the matches operation is: " + res4);
    }
}

Output:

Result of the matches operation is: true

Using String.containsIngnoreCase() Method

IgnoreCase.java

import java.util.regex.Pattern;
import org.apache.commons.lang3.StringUtils;
public class IgnoreCase {
    public static void main(String[] args) {
        String str1 = "Life is like riding a bicycle. To keep your balance, you must keep moving. ALBERT EINSTEIN";
        boolean res1 = str1.toLowerCase().contains("albert".toLowerCase());
        boolean res2 = str1.toLowerCase().contains("ALBERT".toLowerCase());
        //First method
        System.out.println("Result of toLowerCase: " + res1);
        System.out.println("Result of toLowerCase: " + res2);
        //Pattern.compile 
        boolean res3 = Pattern.compile(Pattern.quote("AlBerT"), Pattern.CASE_INSENSITIVE).matcher(str1).find();
        System.out.println("Result is: " + res3);
        //String.matches
        boolean res4 = str1.matches("(?i).*" + "AlBerT" + ".*");
        System.out.println("Result of the matches operation is: " + res4);
        boolean res6 = str1.matches("AlBerT" + ".*");
        System.out.println("Result of the matches operation is: " + res6);
        boolean res5 = StringUtils.containsIgnoreCase(str1, "RiDing");
        System.out.println("Result of StringUtils: " + res5);
    }
}

Output:

Result of toLowerCase: true
Result of toLowerCase: true
Result is: true
Result of the matches operation is: true
Result of the matches operation is: false
Result of StringUtils: true

Understanding the equalsIgnoreCase() Method

The equalsIgnoreCase() method provided by Java to compare two strings while ignoring their case. It returns a boolean value, true if the two strings are equal, ignoring case, false otherwise. We will discuss the syntax and usage of this method in detail, including any limitations or considerations to keep in mind.

Examples and Use Cases

To truly understand the benefits of the equalsIgnoreCase() method, let's explore some practical examples and use cases. We will walk through scenarios where case-insensitive string comparison is essential, such as user input validation, searching and filtering data, and sorting strings. By examining real-world examples, we can grasp the significance of this method and its impact on the functionality of our Java applications.

Performance Considerations

While the `equalsIgnoreCase()` method provides a convenient way to compare strings without considering case, it's essential to be aware of its performance implications. In this chapter, we will discuss the performance considerations associated with using this method. We will explore alternative approaches and techniques that can be employed to optimize string comparison operations, especially in scenarios where performance is critical.

Conclusion

We have explored the power of the equalsIgnoreCase() method in Java for performing case-insensitive string comparisons. We have seen how this method can be utilized effectively in various use cases, providing flexibility and convenience. However, it is crucial to consider the performance implications and explore alternative approaches when necessary. By mastering the art of ignore case string comparison, we can enhance the functionality and user experience of our Java applications.

Next TopicConvert String to Biginteger In Java

← prev next →