Неявное приведение int в String с использованием конкатенации. Конкатенация это плохой способ?

#java

В книге вычитал, что приведение int в String с использованием конкатенации, например,
где а это int

String s = a + "";


это плохой способ. А вот 

String s = Integer.toString(a);


Или

String s = String.valueOf(a);


Это хорошие способы. Почему?
    

Ответы

Ответ 1

Нет, конкатенация - это не плохо. Она выглядит более наглядно и в большинстве случаев,
javac умеет ее оптимизировать с использованием java.lang.StringBuilder. Так же, срабатывает
интернирование, что позволяет не создавать множество объектов. Например,

 String value = "hello world" + 1;
 System.out.println(value == "hello world1");


выведет


  true


А методы Integer.toString и String.valueOf идентичны, т.к. последний делегирует вызов
второму. Но у них есть особенность - при каждом вызове создается новая строка.


Ответ 2

Ну, может быть, если там не просто число, а выражение, не сразу очевидно, что получится
в результате.
Например такой код:

System.out.println(6 + 4 + "");
System.out.println("" + 4 + 6);


В первой строке выведет 10, а во второй - 46.


Ответ 3

Это плохо потому, что Java - это строго типизированный язык, и неявное приведение
типов является нарушением парадигмы языка.

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

Два варианта кода:

String s = a + "";

String s = Integer.toString(a);


Второй является совершенно обычным и стандартным паттерном, который не вызовет никаких
затруднений, а на первом он споткнется и будет пару минут тупить, стараясь понять,
что там происходит и почему решили сделать именно так.


Ответ 4

При использовании конкатенации выполняется несколько ненужных действий:


неявно вызывается Integer.toString(a);
выделяется StringBuffer для конкатенации, куда копируется пустая строка "" и переведённое
в строку число
преобразовывается StringBuffer в строку


Реализация может отличаться и компилятор возможно это оптимизирует, но лучше не использовать
такой метод и явно вызывать преобразование числа в строку.


Ответ 5

Напишем тестовый класс с двумя способами приведения числа к строки:

public class TestString {

    public void intToStringConcat(int value){
        String stringValue = value + "";
    }

    public void intToStringValueOf(int value){
        String stringValue = String.valueOf(value);
    }
}


Байткод для них будет следующий:

  public void intToStringConcat(int);
    Code:
       0: new           #2                  // class java/lang/StringBuilder
       3: dup
       4: invokespecial #3                  // Method java/lang/StringBuilder."":()V
       7: iload_1
       8: invokevirtual #4                  // Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
      11: ldc           #5                  // String
      13: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      16: invokevirtual #7                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      19: astore_2
      20: return

  public void intToStringValueOf(int);
    Code:
       0: iload_1
       1: invokestatic  #8                  // Method java/lang/String.valueOf:(I)Ljava/lang/String;
       4: astore_2
       5: return


Глядя на байткод можно сделать вывод что в случае конкатенации числа со строкой создается
объект StringBuilder, выполняется два раза метод append() и затем toString(). 

Методы StringBuilder.append(int value) и Integer.toString(int values) в конечном
счете вызывают метод Integer.getChars(). Однако для Android метод Integer.toString(int
values) оптимизирован, путем кэширования значений в диапазоне -100..100. Не знаю правда
c какой версии эта оптимизация добавилась, но тем не менее она есть. 

Из всего этого можно сделать вывод, что преобразование числа в строку методом конкатенации
числа с пустой строкой является плохой практикой, особенно критичной в Android, ну
и выглядит не очень красиво. 

Если надо преобразовать число в строку то лучше пользоваться методом Integer.toString(int
values). Если необходимо сформировать строку из нескольких слов и чисел, то конкатенация
не плохой вариант, если она не выполняется в цикле. Конкатенация в цикле вообще плохая
идея.