[java] How do I convert from int to String?

I'm working on a project where all conversions from int to String are done like this:

int i = 5;
String strI = "" + i;

I'm not familiar with Java.

Is this usual practice or is something wrong, as I suppose?

The expression

"" + i

leads to string conversion of i at runtime. The overall type of the expression is String. i is first converted to an Integer object (new Integer(i)), then String.valueOf(Object obj) is called. So it is equivalent to

"" + String.valueOf(new Integer(i));

Obviously, this is slightly less performant than just calling String.valueOf(new Integer(i)) which will produce the very same result.

The advantage of ""+i is that typing is easier/faster and some people might think, that it's easier to read. It is not a code smell as it does not indicate any deeper problem.

(Reference: JLS 15.8.1)

There are many way to convert an integer to a string:

1)

Integer.toString(10);

2)

 String hundred = String.valueOf(100); // You can pass an int constant
 int ten = 10;
 String ten = String.valueOf(ten)

3)

String thousand = "" + 1000; // String concatenation

4)

String million = String.format("%d", 1000000)

Personally I think that "" + i does look as the original question poster states "smelly". I have used a lot of OO languages besides Java. If that syntax was intended to be appropriate then Java would just interpret the i alone without needing the "" as desired to be converted to a string and do it since the destination type is unambiguous and only a single value would be being supplied on the right. The other seems like a 'trick" to fool the compiler, bad mojo when different versions of Javac made by other manufacturers or from other platforms are considered if the code ever needs to be ported. Heck for my money it should like many other OOL's just take a Typecast: (String) i. winks

Given my way of learning and for ease of understanding such a construct when reading others code quickly I vote for the Integer.toString(i) method. Forgetting a ns or two in how Java implements things in the background vs. String.valueOf(i) this method feels right to me and says exactly what is happening: I have and Integer and I wish it converted to a String.

A good point made a couple times is perhaps just using StringBuilder up front is a good answer to building Strings mixed of text and ints or other objects since thats what will be used in the background anyways right?

Just my two cents thrown into the already well paid kitty of the answers to the Mans question... smiles

EDIT TO MY OWN ANSWER AFTER SOME REFLECTION:

Ok, Ok, I was thinking on this some more and String.valueOf(i) is also perfectly good as well it says: I want a String that represents the value of an Integer. lol, English is by far more difficult to parse then Java! But, I leave the rest of my answer/comment... I was always taught to use the lowest level of a method/function chain if possible and still maintains readablity so if String.valueOf calls Integer.toString then Why use a whole orange if your just gonna peel it anyways, Hmmm?

To clarify my comment about StringBuilder, I build a lot of strings with combos of mostly literal text and int's and they wind up being long and ugly with calls to the above mentioned routines imbedded between the +'s, so seems to me if those become SB objects anyways and the append method has overloads it might be cleaner to just go ahead and use it... So I guess I am up to 5 cents on this one now, eh? lol...

use Integer.toString(tmpInt).trim();

It's acceptable, but I've never written anything like that. I'd prefer this:

String strI = Integer.toString(i);

Mostly ditto on SimonJ. I really dislike the ""+i idiom. If you say String.valueOf(i), Java converts the integer to a string and returns the result. If you say ""+i, Java creates a StringBuilder object, appends an empty string to it, converts the integer to a string, appends this to the StringBuilder, then converts the StringBuilder to a String. That's a lot of extra steps. I suppose if you do it once in a big program, it's no big deal. But if you're doing this all the time, you're making the computer do a bunch of extra work and creating all these extra objects that then have to be cleaned up. I don't want to get fanatic about micro-optimization, but I don't want to be pointlessly wasteful either.

It's not only the optimization¹. I don't like

"" + i

because it does not express what I really want to do ².

I don't want to append an integer to an (empty) string. I want to convert an integer to string:

Integer.toString(i)

Or, not my prefered, but still better than concatenation, get a string representation of an object (integer):

String.valueOf(i)

^{1. For code that is called very often, like in loops, optimization sure is also a point for not using concatenation.}

^{2. this is not valid for use of real concatenation like in System.out.println("Index: " + i); or String id = "ID" + i;}

As already pointed out Integer.toString() or String.valueOf() are the way to go. I was curious and did a quick benchmark:

Integer.toString(i) and String.valueOf(i) are basically identical in performance, with Integer.toString(i) being a tiny bit faster. However i + "" is 1.7 times slower.

import java.util.Random;

public class Test {

    public static void main(String[] args) {
        long concat = 0;
        long valueOf = 0;
        long toString = 0;
        
        int iterations = 10000;
        int runs = 1000;
        for(int i = 0; i < runs; i++) {
            concat += concat(iterations);
            valueOf += valueOf(iterations);
            toString += to_String(iterations);
        }
        
        System.out.println("concat: " + concat/runs);
        System.out.println("valueOf: " + valueOf/runs);
        System.out.println("toString: " + toString/runs);
    }
    
    public static long concat(int iterations) {
        Random r = new Random(0);
        long start = System.nanoTime();
        for(int i = 0; i < iterations; i++) {
            String s = r.nextInt() + "";
        }
        return System.nanoTime() - start;
    }
    
    public static long valueOf(int iterations) {
        Random r = new Random(0);
        long start = System.nanoTime();
        for(int i = 0; i < iterations; i++) {
            String s = String.valueOf(r.nextInt());
        }
        return System.nanoTime() - start;
    }
    
    public static long to_String(int iterations) {
        Random r = new Random(0);
        long start = System.nanoTime();
        for(int i = 0; i < iterations; i++) {
            String s = Integer.toString(r.nextInt());
        }
        return System.nanoTime() - start;
    }
}

Output:

concat: 1004109
valueOf: 590978
toString: 587236

A lot of introductory University courses seem to teach this style, for two reasons (in my experience):

• It doesn’t require understanding of classes or methods. Usually, this is taught way before the word “class” is ever mentioned – nor even method calls. So using something like String.valueOf(…) would confuse students.

• It is an illustration of “operator overloading” – in fact, this was sold to us as the idiomatic overloaded operator (small wonder here, since Java doesn’t allow custom operator overloading).

So it may either be born out of didactic necessity (although I’d argue that this is just bad teaching) or be used to illustrate a principle that’s otherwise quite hard to demonstrate in Java.

Using "" + i is the shortest and simplest way to convert a number to a string. It is not the most efficient, but it is the clearest IMHO and that is usually more important. The simpler the code, the less likely you are to make a mistake.

The other way I am aware of is from the Integer class:

Integer.toString(int n);
Integer.toString(int n, int radix);

A concrete example (though I wouldn't think you need any):

String five = Integer.toString(5); // returns "5"

It also works for other primitive types, for instance Double.toString.

See here for more details.

It's not a good way.

When doing conversion from int to string, this should be used:

int i = 5;
String strI = String.valueOf(i);

There are various ways of converting to Strings:

StringBuilder string = string.append(i).toString();
String string = String.valueOf(i);
String string = Integer.toString(i);

It depends on how you want to use your String. This can help:

String total =  Integer.toString(123) + Double.toString(456.789);

There are three ways of converting to Strings

1. String string = "" + i;
2. String string = String.valueOf(i);
3. String string = Integer.toString(i);

Try simple typecasting

char c = (char) i;

Personally, I don't see anything bad in this code.

It's pretty useful when you want to log an int value, and the logger just accepts a string. I would say such a conversion is convenient when you need to call a method accepting a String, but you have an int value.

As for the choice between Integer.toString or String.valueOf, it's all a matter of taste.
...And internally, the String.valueOf calls the Integer.toString method by the way. :)

This technique was taught in an undergraduate level introduction-to-Java class I took over a decade ago. However, I should note that, IIRC, we hadn't yet gotten to the String and Integer class methods.

The technique is simple and quick to type. If all I'm doing is printing something, I'll use it (for example, System.out.println("" + i);. However, I think it's not the best way to do a conversion, as it takes a second of thought to realize what's going on when it's being used this way. Also, if performance is a concern, it seems slower (more below, as well as in other answers).

Personally, I prefer Integer.toString(), as it is obvious what's happening. String.valueOf() would be my second choice, as it seems to be confusing (witness the comments after darioo's answer).

Just for grins :) I wrote up classes to test the three techniques: "" + i, Integer.toString, and String.ValueOf. Each test just converted the ints from 1 to 10000 to Strings. I then ran each through the Linux time command five times. Integer.toString() was slightly faster than String.valueOf() once, they tied three times, and String.valueOf() was faster once; however, the difference was never more than a couple of milliseconds.

The "" + i technique was slower than both on every test except one, when it was 1 millisecond faster than Integer.toString() and 1 millisecond slower than String.valueOf() (obviously on the same test where String.valueOf() was faster than Integer.toString()). While it was usually only a couple milliseconds slower, there was one test where it was about 50 milliseconds slower. YMMV.

String strI = String.valueOf(i);

String string = Integer.toString(i);

Both of the ways are correct.