String equals() Vs contentEquals() in Java

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Distributed systems often come with complex challenges such as service-to-service communication, state management, asynchronous messaging, security, and more.

Dapr (Distributed Application Runtime) provides a set of APIs and building blocks to address these challenges, abstracting away infrastructure so we can focus on business logic.

In this tutorial, we'll focus on Dapr's pub/sub API for message brokering. Using its Spring Boot integration, we'll simplify the creation of a loosely coupled, portable, and easily testable pub/sub messaging system:

>> Flexible Pub/Sub Messaging With Spring Boot and Dapr

1. Introduction

The equals() and the contentEquals() methods of the String class in Java are used to perform String comparison. However, there exist specific differences between the functionalities of these two methods.

In this tutorial, we’ll take a quick look at the differences between these two methods using practical examples.

2. The equals() Method

The equals() method is a public method of the Java String class. It overrides the original equals() method from the Object class. The signature of this method is:

public boolean equals(Object anObject)

The method compares two different Strings by checking individual characters in both. However, the method not only checks for the content, but also checks if the object is an instance of String. Therefore, the method only returns true if all these conditions are satisfied:

the argument object is not null
it’s a String object
the sequence of characters are identical

3. The contentEquals() Method

Similar to the equals() method, the contentEquals() method is also used to compare the String’s content. However, unlike the equals() method, contentEquals() takes any implementation of the CharSequence interface as an argument. That means String, StringBuffer, StringBuilder, CharBuffer, or Segment can be compared.

The signature of this method is:

public boolean contentEquals(StringBuffer sb)
public boolean contentEquals(CharSequence cs)

Therefore, the contentEquals() method is only concerned with the content of the string. If the argument is a String object, the equals() method is called for comparison. On the other hand, if a generic character sequence is provided, the method compares individual characters in similar positions.

The method returns true if the character sequence in the given argument matches the original String. Unlike the equals() method, if a null argument is passed to the contentEquals() method, it throws a NullPointerException.

4. Examples

Let’s see these two methods in action by writing simple test cases. For the sake of simplicity, let’s use the word “Baeldung” for our code.

First, we’ll take two identical String objects and check them. In this case, both methods will return a true value:

String actualString = "baeldung";
String identicalString = "baeldung";

assertTrue(actualString.equals(identicalString));
assertTrue(actualString.contentEquals(identicalString));

Next, we take two different implementations of CharSequence with identical content. For the first implementation, we’ll instantiate CharSequence with a String. In this case, both methods should return true as the content and the types are identical:

CharSequence identicalStringInstance = "baeldung";

assertTrue(actualString.equals(identicalStringInstance));
assertTrue(actualString.contentEquals(identicalStringInstance));

For the next example, we’ll take a StringBuffer implementation. Since the contentEquals() method only checks for the content, it should return true. However, the equals() method should false:

CharSequence identicalStringBufferInstance = new StringBuffer("baeldung");

assertFalse(actualString.equals(identicalStringBufferInstance));
assertTrue(actualString.contentEquals(identicalStringBufferInstance));

5. Conclusion

In this article, we took a quick look at the two methods of the String class. While the equals() method only compares instances of String, the contentEquals() method can compare any implementation of CharSequence.

To conclude, we should use contentEquals() when we are only concerned about the content of the object. On the other hand, sometimes it might be important to check for the type of the object. In that case, we should use the equals() method which gives us stricter checking conditions.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.