Каков наиболее эффективный способ преобразования int в String?

Скажем, у меня есть:

int someValue = 42;

Теперь я хочу преобразовать это значение int в String. Какой способ более эффективен?

// One
String stringValue = Integer.toString(someValue);

// Two
String stringValue = String.valueOf(someValue);

// Three
String stringValue = someValue + "";

Мне просто интересно, есть ли какая-то реальная разница или одна лучше другой?

Ответ 1

проверил его на 10 м присваивания числа 10

One:
real    0m5.610s
user    0m5.098s
sys     0m0.220s

Two:
real    0m6.216s
user    0m5.700s
sys     0m0.213s

Three:
real    0m12.986s
user    0m11.767s
sys     0m0.489s

Кажется, что выигрывает

Изменить: JVM является стандартным "/usr/bin/java" в Mac OS X 10.5

java version "1.5.0_16"
Java(TM) 2 Runtime Environment, Standard Edition (build 1.5.0_16-b06-284)
Java HotSpot(TM) Client VM (build 1.5.0_16-133, mixed mode, sharing)

Больше прав:

Код по запросу

public class One {
    public static void main(String[] args) {
        int someValue = 10;
        for (int i = 0; i < 10000000; i++) {
            String stringValue = Integer.toString(someValue);
        }
    }
}

случай 2 и 3 аналогично
используйте

javac *.java; time java One; time java Two; time java Three

Ответ 2

Несмотря на то, что согласно измерениям cobbal, # 1 кажется самым быстрым, я настоятельно рекомендую использовать String.valueOf(). Моя причина в том, что этот вызов явно не содержит тип аргумента, поэтому, если позже вы решите изменить его из int в double, нет необходимости изменять этот вызов. Увеличение скорости на # 1 по сравнению с № 2 минимально, и, как мы все знаем, "преждевременная оптимизация - это корень всего зла".

Третье решение не может быть и речи, поскольку оно неявно создает StringBuilder и добавляет к нему компоненты (в данном случае, число и пустую строку) и, наконец, преобразует их в строку.

Ответ 3

Первые два примера на самом деле идентичны, поскольку String.valueOf(int) использует метод Integer.toString(int). Третий - уродливый и, вероятно, менее эффективный, так как конкатенация в Java медленная.

Ответ 4

Посмотрите на исходный код JRE, и вы, вероятно, увидите разницу. Или нет. Фактически Strinv.valueOf(int foo) реализуется следующим образом:

public static String valueOf(int i) {
    return Integer.toString(i, 10);
}

и Integer.toString(int foo, int radix)

public static String toString(int i, int radix) {
   ...
   if (radix == 10) {
   return toString(i);
   }
   ...
}

Это означает, что если вы используете radix 10, вам лучше всего вызвать Integer.toString(int foo). Для других случаев используйте Integer.toString(int foo, int radix).

Конкатентное решение сначала преобразует значение int в строку, а затем объединяется с пустой строкой. Это, очевидно, самый дорогой случай.

Ответ 5

(Напротив Давида Ханака.)

Несмотря на то, что согласно измерениям cobbal, # 1 кажется самым быстрым, я настоятельно рекомендую использовать Integer.toString(). Моя причина в том, что этот вызов явно содержит тип аргумента, поэтому, если позже вы решите изменить его из int в double, становится ясно, что этот вызов изменился. Вы бы сделали то же самое, если бы это был двоичный формат, не так ли? Увеличение скорости на # 1 по сравнению с № 2 минимально, и, как мы все знаем, "преждевременная оптимизация - это корень всего зла".

Ответ 6

"" + int медленнее, как показано выше, Дэвидом Ханаком.

String.valueOf() вызовы inturn Integer.toString(). Следовательно, лучше использовать Integer.toString().

Итак, Integer.toString() является самым быстрым..