CharSequence vs. String in Java

1. Introduction

Simply put, CharSequence and String are two different fundamental concepts in Java.

In this quick article, we’re going to have a look at the differences between these types and when to use each one.

2. CharSequence

CharSequence is an interface that represents a sequence of characters. Mutability is not enforced by this interface. Therefore, both mutable and immutable classes implement this interface.

Of course, an interface can’t be instantiated directly; it needs an implementation to instantiate a variable:

CharSequence charSequence = "maixuanviet";

Here, charSequence is instantiated with a String. Instantiating other implementations:

CharSequence charSequence = new StringBuffer("maixuanviet");
CharSequence charSequence = new StringBuilder("maixuanviet");

3. String

String is a sequence of characters in Java. It is an immutable class and one of the most frequently used types in Java. This class implements the CharSequence, Serializable, and Comparable<String> interfaces.

Below both instantiations create Strings with the same content. However, they are not equal to each other:

@Test
public void givenUsingString_whenInstantiatingString_thenWrong() {
    CharSequence firstString = "maixuanviet";
    String secondString = "maixuanviet";

    assertNotEquals(firstString, secondString);
}

4. CharSequence vs. String

Let’s compare the differences and commonalities of CharSequence and String. They both reside in the same package named java.lang., but the former is an interface and latter is a concrete class. Moreover, the String class is immutable.

In the following example, each sum operation creates another instance, increases the amount of data stored and returns the most recently created String:

@Test
public void givenString_whenAppended_thenUnmodified() {
    String test = "a";
    int firstAddressOfTest = System.identityHashCode(test);
    test += "b";
    int secondAddressOfTest = System.identityHashCode(test);

    assertNotEquals(firstAddressOfTest, secondAddressOfTest);
}

On the other hand, StringBuilder updates the already created String to hold the new value:

@Test
public void givenStringBuilder_whenAppended_thenModified() {
    StringBuilder test = new StringBuilder();
    test.append("a");
    int firstAddressOfTest = System.identityHashCode(test);
    test.append("b");
    int secondAddressOfTest = System.identityHashCode(test);        
    
    assertEquals(firstAddressOfTest, secondAddressOfTest);
}

Another difference is that the interface does not imply a built-in comparison strategy, whereas the String class implements the Comparable<String> interface.

To compare two CharSequences, we can cast them to Strings then subsequently compare them:

@Test
public void givenIdenticalCharSequences_whenCastToString_thenEqual() {
    CharSequence charSeq1 = "maixuanviet_1";
    CharSequence charSeq2 = "maixuanviet_2";
 
    assertTrue(charSeq1.toString().compareTo(charSeq2.toString()) > 0);
}

5. Conclusion

We usually use String in the places where we’re not sure what to use for char sequences. However, in some cases, StringBuilder and StringBuffer can be more appropriate.

You can find more information in JavaDocs about CharSequence and String.

And, as always, the implementation of all these examples and code snippets can be found over on Github.