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

Question

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

String s = a + "";

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

String s = Integer.toString(a);

Или

String s = String.valueOf(a);

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

Answer 1

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

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

выведет

true

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

Answer 2

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

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

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

Answer 3

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

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

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

String s = a + "";

String s = Integer.toString(a);

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

Answer 4

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

• неявно вызывается Integer.toString(a);

• выделяется StringBuffer для конкатенации, куда копируется пустая строка "" и переведённое в строку число

• преобразовывается StringBuffer в строку

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

Answer 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."<init>":()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). Если необходимо сформировать строку из нескольких слов и чисел, то конкатенация не плохой вариант, если она не выполняется в цикле. Конкатенация в цикле вообще плохая идея.