Преобразование в String с использованием ("" + <int value>) плохой практики?

Преобразование в String в Java с помощью

"" + <int value>

плохая практика? Имеются ли у него недостатки по сравнению с String.valueOf(...)?

Пример кода:

int i = 25;
return "" + i;

против

int i = 25;
return String.valueOf(i);

Обновление: (из комментария)

А как насчет Integer.toString(int i) по сравнению с String.valueOf(...)?

Ответ 1

Я бы всегда предпочитал версию String.valueOf: в основном потому, что она показывает, что вы пытаетесь сделать. Цель - не конкатенация строк - это преобразование в строку, "строковое значение i".

Первая форма также может быть неэффективной - в зависимости от того, видит ли компилятор то, что вы делаете. Если это не так, это может быть создание нового StringBuffer или StringBuilder и добавление значения, а затем преобразование его в строку.

Как ни странно, у меня есть статья об этой самой теме - написана годами и годами; одна из первых статей Java на моем веб-сайте, IIRC.

Ответ 2

Существует также Integer.toString(int i), который дает вам возможность получить строку как шестнадцатеричное значение (по передавая второй параметр 16).

Изменить Я только что проверил источник класса String:

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

И класс Integer:

public static String toString(int i, int radix) {
  if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
    radix = 10;

  /* Use the faster version */
  if (radix == 10) {
    return toString(i);
  }
  ...

Если вы вызываете String.valueOf(i), он вызывает Integer.toString(i, 10), который затем вызывает Integer.toString(i).

Итак, Integer.toString(i) должен быть очень слабее, чем String.valueOf(i), так как вы будете вырезать два вызова функций. (Хотя первый вызов функции может быть оптимизирован компилятором.)

Конечно, для String.valueOf() можно было бы еще аргументировать читаемость, поскольку он позволяет вам изменять тип аргумента (и даже обрабатывать нули!), а разница в производительности незначительна.

Ответ 3

Определенно используйте String.valueOf(i).

Хотя я не уверен в оптимизации на стороне компилятора, худшем случае, если вы используете "+":

"" создает новую пустую строку.
"" + создает StringBuilder (Java 1.5-16)
"" добавляется к StringBuilder, затем

Другими словами, есть много накладных расходов, которые возникают, если вы используете добавление строк. Вот почему не рекомендуется использовать оператор + в строках в циклах. В общем, всегда используйте Boolean.valueOf, Integer.valueOf, String.valueOf... и т.д., Когда это возможно. Вы сохраните как по памяти, так и по накладным расходам.

Ответ 4

Независимо от любых соображений производительности, я думаю, что первый вариант действительно уродлив. ИМХО, это позор, что такой "динамический кастинг" возможен даже на Java.

Ответ 5

Да, это ИМХО - плохая практика.

Это потребует выделения памяти (если только компилятор и/или JIT не оптимизируют их). Чем больше, тем менее очевидно, что этот код пытается сделать.

Ответ 6

Лично мне не нравится стиль "" + i, но это действительно стандарт предпочтений/стандартов кодирования. В идеале компилятор оптимизирует их в эквивалентный код (хотя вам придется декомпилировать, чтобы убедиться, что это действительно так), но технически без оптимизации "" + i более неэффективен, поскольку он создает объект StringBuilder, который не нужен.

Ответ 7

С самого начала я могу думать, что в первом примере будут созданы более String-объекты, чем во втором примере (и дополнительный StringBuilder для фактического выполнения конкатенации).

Но то, что вы на самом деле пытаетесь сделать, это создать объект String из int, не конкатенировать String с int, поэтому перейдите к:

String.valueOf(...);

вариант,

Итак, ваш первый вариант - плохая практика!