Преобразование должно Представить использование в виде строки (“” + <международное значение>) плохая практика?

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

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

Edit Я только что проверил источник класса 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) , поскольку ты' d будет вырезать два вызова функций. (Хотя первый вызов функции может быть оптимизирован компилятором.)

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

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

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

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

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

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

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

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

String.valueOf(...); 

,

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

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

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