Согласно инструменту PMD, следующее является плохой практикой:
String s = "" + 123; // bad
String t = Integer.toString(456); // ok
This is an inefficient way to convert any type to a `String`.
Почему это плохо?
Согласно инструменту PMD, следующее является плохой практикой:
String s = "" + 123; // bad
String t = Integer.toString(456); // ok
This is an inefficient way to convert any type to a `String`.
Почему это плохо?
String s = "" + 123; // bad
String t = Integer.toString(456);
Будет скомпилирован в:
String s = "123";
String t = Integer.toString(456);
так: "" +123, очевидно, немного лучше! Проверено с помощью JAD
public static void main(String args[])
{
// 0 0:ldc1 #16 <String "123">
// 1 2:astore_1
// 2 3:sipush 456
// 3 6:invokestatic #18 <Method String Integer.toString(int)>
// 4 9:astore_2
// 5 10:getstatic #24 <Field PrintStream System.out>
// 6 13:new #30 <Class StringBuilder>
// 7 16:dup
// 8 17:aload_1
// 9 18:invokestatic #32 <Method String String.valueOf(Object)>
// 10 21:invokespecial #38 <Method void StringBuilder(String)>
// 11 24:aload_2
// 12 25:invokevirtual #41 <Method StringBuilder StringBuilder.append(String)>
// 13 28:invokevirtual #45 <Method String StringBuilder.toString()>
// 14 31:invokevirtual #48 <Method void PrintStream.println(String)>
// 15 34:return
}
РЕДАКТИРОВАТЬ:
Для непостоянных значений:
int i = 123;
String s = (new StringBuilder()).append(i).toString();
String t = Integer.toString(i);
System.out.println((new StringBuilder(String.valueOf(s))).append(t).toString());
public static void main(String args[])
{
// 0 0:bipush 123
// 1 2:istore_1
// 2 3:new #16 <Class StringBuilder>
// 3 6:dup
// 4 7:invokespecial #18 <Method void StringBuilder()>
// 5 10:iload_1
// 6 11:invokevirtual #19 <Method StringBuilder StringBuilder.append(int)>
// 7 14:invokevirtual #23 <Method String StringBuilder.toString()>
// 8 17:astore_2
// 9 18:iload_1
// 10 19:invokestatic #27 <Method String Integer.toString(int)>
// 11 22:astore_3
// 12 23:getstatic #32 <Field PrintStream System.out>
// 13 26:new #16 <Class StringBuilder>
// 14 29:dup
// 15 30:aload_2
// 16 31:invokestatic #38 <Method String String.valueOf(Object)>
// 17 34:invokespecial #44 <Method void StringBuilder(String)>
// 18 37:aload_3
// 19 38:invokevirtual #47 <Method StringBuilder StringBuilder.append(String)>
// 20 41:invokevirtual #23 <Method String StringBuilder.toString()>
// 21 44:invokevirtual #50 <Method void PrintStream.println(String)>
// 22 47:return
}
"" + 123
становится "123"
, потому что вы указываете константу. Теперь попробуйте "" + Math.random()
против String.valueOf(Math.random())
.
- person Chris Jester-Young; 02.09.2010
x
равно static final
.
- person Chris Jester-Young; 02.09.2010
"" + 123
ничуть не лучше, это эквивалентно объявлению новой статической строки со значением "123"
и не имеет ничего общего с int 123
.
- person Nathan; 17.09.2012
Это неэффективно, так как включает ненужную конкатенацию строк, таким образом, создание одного или двух дополнительных String
объектов - хотя я считаю, что JIT может оптимизировать его.
Для меня большая проблема в том, что код менее понятен. Вызов toString
- это стандартная идиома, понятная каждому Java-разработчику (надеюсь :-), так что вам следует предпочесть это.
Он расширяется до "" + String.valueOf (yourObject) и, таким образом, выполняет ненужную конкатенацию. Конкатенация включает выделение дополнительной строки и создание дополнительной копии значения строки.
new StringBuilder().append("").append(yourObject).toString()
, предполагая, что yourObject
не является константой.
- person Chris Jester-Young; 02.09.2010
String s = "" + 123; // bad
Приведенный выше код создает временную строку для объединения "" и 123