Thêm một chuỗi trống vs toString - tại sao nó xấu?

Question

Theo công cụ PMD, sau đây là một thói quen xấu:

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


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

Tại sao nó là một điều xấu để làm gì?

Answer 1

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

sẽ được biên dịch để:

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

vậy: "" 123 là rõ ràng tốt hơn một chút! Checked với 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:

Đối với giá trị không đổi:

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

Nó mở rộng thành "" + String.valueOf (yourObject) và do đó thực hiện một kết nối không cần thiết. Việc ghép nối liên quan đến việc phân bổ chuỗi thừa và thực hiện thêm một bản sao giá trị của chuỗi.

Answer 3

Đó là không hiệu quả, vì nó liên quan đến một chuỗi không cần thiết nối, do đó việc tạo ra một hoặc hai đối tượng String bổ sung - mặc dù tôi tin rằng JIT có thể tối ưu hóa nó đi.

Đối với tôi, vấn đề lớn hơn là mã ít rõ ràng hơn. Gọi toString là một thành ngữ tiêu chuẩn, dễ hiểu đối với mọi nhà phát triển Java (hy vọng :-), vì vậy bạn nên thích điều này.

Answer 4

String s = "" + 123; // bad 

Đoạn mã trên tạo ra một chuỗi tạm thời, kết hợp "" và 123