x.toString() 和 x+"" 的区别

Question

Back in college one of my profs. taught us to just do x + "" as a quick conversion from basic types to strings.
I don't remember which class it was in I had him for some Java and C++ courses(I haven't used either for some time now), but I use it in C#/.Net now which is what I'm primarily developing in lately.

Is there an advantage to using .toString() over +"" for basic types such at int, decimal, float...? What cases would .toString() be better?

Note:I was shown .toString() as well, that prof just recommended +"" because it was shorter and I have just done that since then without questioning it.

Answer 1

Well, as a side note, it depends on what x is. If x is a primitive in Java, you have to call .toString() using one of its wrappers, like

Integer.toString(x)

I would say using toString() is generally better, because x + "", in at least Java, is saying you want to append the two Strings together.

Like in this example:

 public static void main(String[] args)
 {
   int x = 3;
   String s = x + "";   
 }

That ends up, in bytecode, as :

public static void main(java.lang.String[]);
  Code:
   0:   iconst_3
   1:   istore_1
   2:   new #2; //class java/lang/StringBuilder
   5:   dup
   6:   invokespecial   #3; //Method java/lang/StringBuilder."<init>":()V
   9:   iload_1
   10:  invokevirtual   #4; //Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
   13:  ldc #5; //String 
   15:  invokevirtual   #6; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   18:  invokevirtual   #7; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;
   21:  astore_2
   22:  return

So it has to create a StringBuilder to append "" and the String value of x together. While the efficiency lost isn't that much, it isn't too much to just use the toString function.

Compare with using toString:

 public static void main(String[] args)
 {
   int x = 3;
   String s = Integer.toString(x); 
 }

Which ends up as:

public static void main(java.lang.String[]);
Code:
 0: iconst_3
 1: istore_1
 2: iload_1
 3: invokestatic    #2; //Method java/lang/Integer.toString:(I)Ljava/lang/String;
 6: astore_2
 7: return

And although it might just be my opinion, using .toString reflects what you actually want -- you want the String value of x, while using x + "" is kind of a hack and says -- I want the String value of x concatenated with "".

Side Note: I can't speak on the intermediate bytecode C# would emit, but I imagine something similar to this. Plus, with C#, you can just call .ToString() on your value types just as easily as reference types, so I think my advice would apply the same.

Answer 2

Honestly, I consider that kind of weird advice.

I can't speak to every specific case, but in general what x + "" will do in C# (which should depend on the existence of an overloaded + operator for either the type of x or string ) is call something like string.Concat(x, "") which in turn will invoke x.ToString anyway.

In the typical case, this just means that x + "" has the overhead of one more method call than x.ToString . When x is a variable of some value type, however, this can also cause the value of x to be boxed unless an overload for + exists specifically for the type of x (this might be considered a useless point to make, as x will also be boxed in a call to ToString if its type has not overridden that method; this strikes me aa bit rarer, but it most assuredly does happen).

These are fairly trivial differences, of course. The real difference between these two approaches is that of readability; in my experience, x + "" is not very idiomatic in .NET and so I would be inclined to avoid it. That said, it could just be that it isn't common in the slice of the .NET world I inhabit, while there could be plenty of .NET developers out there who do it.

I will point out that while in Java, perhaps you had to write the unwieldy Integer.toString(x) for variables x of primitive types like int , in C# and in .NET in general all types (including so-called "primitive" ones) inherit from object and so have the method ToString (along with GetType and GetHashCode ) available to them.

Answer 3

In Java, for primitive types ( int , double , etc.) you cannot write .toString() because the types aren't objects. This means that your options are either to write something like

x + "";

or to use

Integer.toString(x);

In C++, you cannot use x + "" to do this sort of conversion, since this will be treated as pointer arithmetic and will give you a bad pointer. Using something like boost::lexical_cast is the preferred way to do the conversion.

And... I know nothing about C#, so I won't comment on it. :-)

Answer 4

There are no advantages or disadvantages of using x+"" . toString is the method of Object type which implicitly called every time you add any object to string.

You can always override this method in your class if you'd like.

Answer 5

Because strings are immutable, x+"" invokes two functions: x.toString() and StringBuffer.append() (in Java, at least). I imagine most good JITs would simply turn that into a single function call, x.toString(), but I couldn't be sure without actually testing.

Answer 6

It doesn't matter, really. It is very very unlikely this will cause any performance problems whatsoever. So it remains a matter of personal style. Use whatever you or your team is comfortable with.

Answer 7

In Java,

In addition to working with primitive types, x+"" also works with null . Where x.toString() throws a NullPointerException , x+"" returns "null" . Whether that is better or not is up to you, but it is a difference.

Answer 8

In C# I would completely disregard this advice in favor of something more declarative such as using .ToString directly.

The only potential advantage this syntax provides you is it will create an empty string if x is null . I would favor an extension method if this is considered an advantage in your code.

public static string NullSafeToString<T>(this T value) where T : class {
  return value == null ? "" : value.ToString();
}

The other reason to avoid this is because it can create precedence confusion. For example do you know exactly what the value of z is in the following scenario without the use of reference materials?

int x = 42;
int y = 15;
string z = x + y + "";

Now same question with the following

int x = 42;
int y = 15;
string z = x + y.ToString();

The latter is more likely to be understood at a glance by the average developer who hasn't taken the time to memory C# operator precedence. Hence I would prefer it because it has a lesser chance of being misunderstood.