Convert Integer, Double to String in Java

I don't think there's a performance difference. Go for the most readable!

The first one is exactly equivalent to doublevar.toString() (check the javadoc). The second one is more suited for concatenating longer strings.

If you need to format the way your number is represented as a String, you anyway need to look into other classes

The first and the third are good, the second is bad.

The reason that the second is bad is because the code doesn't show what you want to do. The code says that you want to concatentate the value with an empty string, when you actually want only the conversion that happens before the concatenation.

I prefer to use Integer.toString(int), when you use String.valueOf(int), it internally calls to Integer.toString(int) (same with long, float and double). But for readability, it would be better to use String.valueOf()

There are slight semantic differences depending on whether you're using the primitive double type, or its object wrapper Double.

Anything that will work for a primitive double will also work for the object wrapped Double, but the opposite will not work. (That is, a primitive double will not be accepted if the parameter is of type Double.)

Also, the Double type's value may be null, but the primitive double type cannot.

Beyond that, there isn't much difference at all. For the code snippets you've provided, there isn't any worth really talking about.

i) String.valueOf(int i) ii) Integer.toString(int i)

After looking the implementation of these methods I saw that the first one is calling the second one. As a consequence all my calls to String.valueOf(int i) involve one more call than directly calling Integer.toString(int i)

Just two different ways of doing the same thing

In String type we have several method valueOf

static String   valueOf(boolean b) 
static String   valueOf(char c) 
static String   valueOf(char[] data) 
static String   valueOf(char[] data, int offset, int count) 
static String   valueOf(double d) 
static String   valueOf(float f) 
static String   valueOf(int i) 
static String   valueOf(long l) 
static String   valueOf(Object obj) 

As we can see those method are capable to resolve all kind of numbers

every implementation of specific method like you have presented: So for double

Double.toString(dobule d)

and so on

In my opinion this is not some historical thing, but is more useful for developer to use the method valueOf from String class than from proper type, because is less changes to make when we want to change the type that we operate on.

Sample 1:

public String doStaff(int num) {

 //Do something with num 

  return String.valueOf(num);

 }

Sample2:

public String doStaff(int num) {

 //Do somenthing with num

 return Integer.toString(num);

 }

As we see in sample 2 we have to do two changes, in contrary to sample one.

My conclusion is that using the valueOf method from String class is more flexible and that why is available there.

From the official source:

public static String valueOf(double d) {
    return Double.toString(d);
}

So the first and the third are not really different, as long as doubleVal is double and not Double. This is because in the case of a Double, you will call

public static String valueOf(Object obj) {
    return (obj == null) ? "null" : obj.toString();
}

The second is certainly worse because of the need to concatenate.

CONCLUSION:

Following the question, I must assume that the most efficient way is to call the toString() method.

Java string.valueOf() method converts different types of value such as long,int,double,float into String.

Double double_val=45.9; String string_conversion=String.valueOf(double_val);