Agregue una cadena vacía vs toString - ¿por qué es malo?

Question

De acuerdo con la herramienta PMD, la siguiente es una mala práctica:

String s = "" + 123; // bad 
String t = Integer.toString(456); // ok 


This is an inefficient way to convert any type to a `String`. 

¿Por qué es una mala cosa que hacer?

Answer 1

String s = "" + 123; // bad  
String t = Integer.toString(456); 

se compilará a:

String s = "123"; 
String t = Integer.toString(456); 

así: "" 123 es obvia poco mejor! comprobado con 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 
} 

EDIT:

Para valores no constantes:

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 
    } 

Answer 2

Se expande a "" + String.valueOf (yourObject) y, por lo tanto, realiza una concatenación innecesaria. La concatenación implica asignar una cadena adicional y hacer una copia adicional del valor de la cadena.

Answer 3

Es ineficaz, ya que implica una cadena de concatenación innecesaria, por lo tanto la creación de uno o dos objetos adicionales String, aunque creo que el JIT puede optimizarlo.

Para mí, el problema más grande es que el código es menos claro. Llamar a toString es una expresión estándar, comprensible para todos los desarrolladores de Java (con suerte :-), por lo que debería preferir esto.

Answer 4

String s = "" + 123; // bad 

El código anterior crea una cadena temporal, para combinar "" y 123