Which toString technique is more efficient?

Question

I have a class called Zebra (not her actual name). Zebra overrides the toString method to provide her own convoluted obfuscated stringification.

Which is more efficient to stringify an instance of Zebra? Presuming that I have to do this stringification millions of times per session.

zebra.toString()
""+zebra
static String BLANK (singleton)
BLANK+zebra (multiple executions).

Where the value of zebra is not assured to be the same.

I am conjecturing that the answer could be - no concern: the compiler makes them all equivalent. If that is not the answer, please describe the instantiation process that makes them different. (2) and (3) could be the same, since the compiler would group all similar strings and assign them to a single reference.

Normally, I do ""+zebra because I am too lazy to type zebra.toString().

ATTN: To clarify.

I have seen questions having been criticised like "why do you want to do this, it's impractical" If every programmer refrains from asking questions because it has no practical value, or every mathematician does the same - that would be the end of the human race.

If I wrote an iteration routine, the differences might be too small. I am less interested in an experimental result than I am interested in the difference in processes:

For example, zebra.toString() would invoke only one toString while, "+zebra would invoke an extra string instantiation and and extra string concat. Which would make it less efficient. Or is it. Or does the compiler nullify that.

Please do not answer if your answer is focused on writing an iterative routine, whose results will not explain the compiler or machine process.

Virtue of a good programmer = lazy to write code but not lazy to think.

`"" + zebra` or `BLANK + zebra` would implicitly call `zebra.toString()` anyways on top of the string concatenation operator. — NullUserException, Oct 31 '11 at 18:23
Just type `.toString()`. If you're that lazy, use an editor with autocomplete. — Mat, Oct 31 '11 at 18:24
"*Millions of times per session*" on **separate** `Zebra` instances? — mre, Oct 31 '11 at 18:26

score 2 · Answer 1 · answered Oct 31 '11 at 20:39

Number 1 is more efficient.

The other options create an instance of StringBuilder, append an empty string to it, call zebra.toString, append the result of this to the StringBuilder, and then convert the StringBuilder to a String. This is a lot of unnecessary overhead. Just call toString yourself.

This is also true, by the way, if you want to convert a standard type, like Integer, to a String. DON'T write

String s=""+n; // where "n" is an Integer

DO write

String s=n.toString();

or

String s=String.valueOf(n);

Thank you for writing a sensible answer. – Blessed Geek Nov 01 '11 at 00:47 — Blessed Geek, Nov 01 '11 at 00:47

score 1 · Accepted Answer · answered Oct 31 '11 at 18:48

1

As a general rule, I would never use the + operator unless it is on very small final/hard-coded strings. Using this operator usually results in several extra objects in memory being created before your resulting string is returned (this is bad, especially if it happens "millions of times per session").

If you ever do need to concatenate strings, such as when building a unique statement dynamically (for SQL or an output message for example). Use a StringBuilder!!! It is significantly more efficient for concatenating strings.

In the case of your specific question, just use the toString() method. If you dont like typing, use an IDE (like eclipse or netbeans) and then use code completion to save you the keystrokes. just type the first letter or 2 of the method and then hit "CTRL+SPACE"

answered Oct 31 '11 at 18:48

gnomed

5,483
2
26
28

Just adding Strings together using the + operator doesn't create additional object. E.g. "a" + "b" + "c" will be converted to `new StringBuilder().append("a").append("b").append("c")` at compile time. But if you use `String someString = "a"; someString += "b"; someString +="c";` Then you will have the intermediate objects you describe above. See http://stackoverflow.com/questions/1532461/stringbuilder-vs-string-concatenation-in-tostring-in-java – Fredrik LS Oct 31 '11 at 19:35
good to know. still a good rule to follow imho, unless you gain major readability using the `+`. Although in the case of this particular question, `""` is always going to be a useless object. – gnomed Oct 31 '11 at 21:46
I agree with using a StringBuilder when concatenating Strings. Although `""` is a String literal and will be put in the constant String pool the first time it's referenced, so I guess `""` will be reused between invocations (`"" + zebra` will of course create a new String for each invocation). – Fredrik LS Oct 31 '11 at 21:57
Thank you for writing your reasoning for your answer and thank you Fredrik for counter-arguing. – Blessed Geek Nov 01 '11 at 00:49

Steve Kuo · Answer 3 · 2011-10-31T20:31:24.213

1

zebra.toString() is the best option. Keep in mind zebra might be null, in which case you'll get a NullPointerException. So you might have to do something like

String s = zebra==null ? null : zebra.toString()

""+zebra results in a StringBuilder being created, then "" and zebra.String() are appended separately, so this is less efficient. Another big difference is that if zebra is null, the resulting string will be "null".

edited Oct 31 '11 at 20:31

answered Oct 31 '11 at 20:26

Steve Kuo

61,876
75
195
257

Thank for giving a sensible answer. – Blessed Geek Nov 01 '11 at 00:40

score 0 · Answer 4 · answered Oct 31 '11 at 18:27

If the Zebra is Singleton class or the same instance of zebra is being used then you can store the result of toString in Zebra and reuse it for all future calls to toString.

If its not the case then in implementation of toString cache the part which is unchanges everytime in constructing String at one place, this was you can save creating some string instances every time.

Otherwise I do not see any escape from the problem you have :(

score 0 · Answer 5 · answered Oct 31 '11 at 18:36

0

Option 1 is the best option since every option calls the toString() method of zebra, but options 2 and 3 also do other (value free) work.

zebra.toString() - Note that this calls the toString() method of zebra.
""+zebra - This also calls the toString() method of zebra.
static String BLANK; BLANK+zebra; - This also calls the toString() method of zebra.

You admit "I'm lazy so I do stupid stuff". If you are unwilling to stop being lazy, than I suggest you not concern yourself with "which is better", since lazy is likely to trump knowledge.

answered Oct 31 '11 at 18:36

DwB

37,124
11
56
82

Yeah, compiler designers rightfully assume most programmers won't bother with any sort of optimization. Thank heaven for clever people who allow us to be dumber :D – G_H Oct 31 '11 at 18:39
#2 and #3 creates a StringBuilder and then appends `""` and `zebra.toString()`. – Steve Kuo Oct 31 '11 at 20:22
Why type zebra+toString() when you can type ""+zebra? – Blessed Geek Nov 01 '11 at 00:42

score 0 · Answer 6 · answered Oct 31 '11 at 18:36

Since the object's toString method will be invoked implicitly in cases where it is not invoked explicitly, a more "efficient" way doesn't exist unless the "stringification" is happening to the same object. In that case, it's best to cache and reuse instead of creating millions of String instances.

Anyway, this question seems more focused on aesthetics/verbosity than efficiency/performance.

score -1 · Answer 7 · answered Oct 31 '11 at 18:41

-1

If you want to know things like this you can code small example routines and look at the generated bytecode using the javap utility.

I am conjecturing that the answer could be - no concern: the compiler makes them all equivalent. [...] Normally, I do ""+zebra because I am too lazy to type zebra.toString().

Two things:

First: The two options are different. Think about zebra being null.

Second: I'm to lazy to do this javap stuff for you.

answered Oct 31 '11 at 18:41

A.H.

63,967
15
92
126

@BlessedGeek I did and found nothing new. The `javap` tip is still valid: Try and check the output ofcompiler yourself and look into the code of the mentioned methods. It's easy and can be done yourself. Virtue of a good scientist: Check the facts yourself, think about what you've found and don't belief hearsay. – A.H. Nov 01 '11 at 09:07

Which toString technique is more efficient?

7 Answers7