Exact difference between CharSequence and String in java

charsequence, java, string

Solution

General differences

There are several classes which implement the `CharSequence` interface besides `String`. Among these are

- `StringBuilder` for variable-length character sequences which can be modified

- `CharBuffer` for fixed-length low-level character sequences which can be modified

Any method which accepts a `CharSequence` can operate on all of these equally well. Any method which only accepts a `String` will require conversion. So using `CharSequence` as an argument type in all the places where you don't care about the internals is prudent. However you should use `String` as a return type if you actually return a `String`, because that avoids possible conversions of returned values if the calling method actually does require a `String`.

Also note that maps should use `String` as key type, not `CharSequence`, as map keys must not change. In other words, sometimes the immutable nature of `String` is essential.

Specific code snippet

As for the code you pasted: simply compile that, and have a look at the JVM bytecode using `javap -v`. There you will notice that both `obj` and `str` are references to the same constant object. As a `String` is immutable, this kind of sharing is all right.

The `+` operator of `String` is compiled as invocations of various `StringBuilder.append` calls. So it is equivalent to

System.out.println(
  (new StringBuilder())
  .append("output is : ")
  .append((Object)obj)
  .append(" ")
  .append(str)
  .toString()
)

I must confess I'm a bit surprised that my compiler `javac 1.6.0_33` compiles the `+ obj` using `StringBuilder.append(Object)` instead of `StringBuilder.append(CharSequence)`. The former probably involves a call to the `toString()` method of the object, whereas the latter should be possible in a more efficient way. On the other hand, `String.toString()` simply returns the `String` itself, so there is little penalty there. So `StringBuilder.append(String)` might be more efficient by about one method invocation.

Problem

I read this previous post. Can any one say what the exact difference between `CharSequence` and String is, other than the fact that `String` implements `CharSequence` and that `String` is a sequence of character? For example: ``` CharSequence obj = "hello"; String str = "hello"; System.out.println("output is : " + obj + " " + str); ``` What happens when "hello" is assigned to `obj` and again to `str` ?

Original source

Related problems