1. Introduction
In this article, we’ll provide a brief explanation of the differences between String casting and executing the toString() method. We’ll briefly review both syntaxes and go through an example explaining the purposes of using each of them. Finally, we’ll take a look at which one is a better approach.
2. String Type Casting and the toString() Method
Let’s start by making a quick recap. Using the (String) syntax is strictly connected with type casting in Java. In short, the main task of using this syntax is casting a source variable into the String:
String str = (String) object;
As we know, every class in Java is an extension, either directly or indirectly, of the Object class, which implements the toStr**ing() method. We use it to get a String representation of any Object:
String str = object.toString();
Now that we’ve made a short recap let’s go through some examples to help understand when to use each approach.
3. (String) vs toString()
Consider we have an Object variable, and we want to obtain a String. Which syntax should we use?
Before moving on, we should emphasize that the following utility method is only used to help explain our topic. In reality, we wouldn’t use utility methods like this.
Firstly, we let’s introduce a simple utility method to cast an Object into a String:
public static String castToString(Object object) {
if (object instanceof String) {
return (String) object;
}
return null;
}
As we can see, before casting, we have to check that our object variable is an instance of a String. If we don’t, it might fail and generate a ClassCastException:
@Test(expected = ClassCastException.class)
public void givenIntegerObject_whenCastToObjectAndString_thenCastClassException() {
Integer input = 1234;
Object obj = input;
String str = (String) obj;
}
However, this operation is null-safe. Using it on a non-instantiated variable, even if it hasn’t been applied to a String variable before, will succeed:
@Test
public void givenNullInteger_whenCastToObjectAndString_thenSameAndNoException() {
Integer input = null;
Object obj = input;
String str = (String) obj;
assertEquals(obj, str);
assertEquals(str, input);
assertSame(input, str);
}
Now, it’s time to implement another utility function calling toString() on the requested object:
public static String getStringRepresentation(Object object) {
if (object != null) {
return object.toString();
}
return null;
}
In this case, we don’t need to know the object’s type, and it can be successfully executed on an object without typecasting. We only have to add a simple null check. If we don’t add this check, we could get a NullPointerException when passing a non-instantiated variable to the method:
@Test(expected = NullPointerException.class)
public void givenNullInteger_whenToString_thenNullPointerException() {
Integer input = null;
String str = input.toString();
}
Moreover, due to the core String implementation, executing the toString() method on a String variable returns the same object:
@Test
public void givenString_whenToString_thenSame() {
String str = "baeldung";
assertEquals("baeldung", str.toString());
assertSame(str, str.toString());
}
Let’s get back to our question – which syntax should we use on our object variable? As we’ve seen above, if we know that our variable is a String instance, we should use type casting:
@Test
public void givenString_whenCastToObject_thenCastToStringReturnsSame() {
String input = "baeldung";
Object obj = input;
assertSame(input, StringCastUtils.castToString(obj));
}
This approach is generally more efficient and quicker because we don’t need to perform additional function calls. But, let’s remember, we should never pass around a String as an Object. This would hint that we have a code smell.
When we pass any other object type, we need to call the toString() method explicitly. It is important to remember that it returns a String value according to the implementation:
@Test
public void givenIntegerNotNull_whenCastToObject_thenGetToStringReturnsString() {
Integer input = 1234;
Object obj = input;
assertEquals("1234", StringCastUtils.getStringRepresentation(obj));
assertNotSame("1234", StringCastUtils.getStringRepresentation(obj));
}
4. Conclusion
In this short tutorial, we’ve compared two approaches: String type casting and getting a string representation using the toString() method. Through the examples, we’ve explained the differences and explored when to use (String) or toString().
As always, the full source code of the article is available over on GitHub.