Có tốt hơn khi sử dụng lại một StringBuilder trong một vòng lặp không?

Question

Tôi có một câu hỏi liên quan đến hiệu suất liên quan đến việc sử dụng StringBuilder. Trong một vòng rất dài tôi đang thao tác một StringBuilder và đi qua nó để phương pháp khác như thế này:

for (loop condition) { 
    StringBuilder sb = new StringBuilder(); 
    sb.append("some string"); 
    . . . 
    sb.append(anotherString); 
    . . . 
    passToMethod(sb.toString()); 
} 

là instantiating StringBuilder tại mỗi chu kỳ vòng lặp là một giải pháp tốt? Và đang kêu gọi xóa thay vì tốt hơn, như sau?

StringBuilder sb = new StringBuilder(); 
for (loop condition) { 
    sb.delete(0, sb.length); 
    sb.append("some string"); 
    . . . 
    sb.append(anotherString); 
    . . . 
    passToMethod(sb.toString()); 
} 

Answer 1

JVM hiện đại thực sự thông minh về những thứ như thế này. Tôi sẽ không đoán trước và làm điều gì đó hacky ít bảo trì/dễ đọc hơn ... trừ khi bạn làm các nhãn hiệu băng ghế phù hợp với dữ liệu sản xuất xác nhận sự cải thiện hiệu suất không tầm thường (và ghi lại nó;)

Answer 2

Alas I'm trên C# bình thường, tôi nghĩ rằng thanh toán bù trừ một trọng lượng StringBuilder nhiều hơn instanciating một cái mới.

Answer 3

Trong triết lý viết mã vững chắc, nó luôn luôn tốt hơn để đặt StringBuilder của bạn bên trong vòng lặp của bạn. Bằng cách này nó không đi bên ngoài mã của nó dành cho.

Thứ hai các improvment lớn nhất trong StringBuilder đến từ cho nó một kích thước ban đầu để tránh nó ngày càng lớn trong khi vòng lặp chạy

for (loop condition) { 
    StringBuilder sb = new StringBuilder(4096); 
} 

Answer 4

Dựa trên kinh nghiệm của tôi với phát triển phần mềm trên Windows tôi sẽ nói xóa StringBuilder ra trong vòng lặp của bạn có hiệu suất tốt hơn so với việc tạo một StringBuilder với mỗi lần lặp. Xóa nó giải phóng bộ nhớ đó sẽ bị ghi đè ngay lập tức mà không yêu cầu phân bổ bổ sung. Tôi không quen thuộc với bộ thu gom rác Java, nhưng tôi nghĩ rằng việc giải phóng và không phân bổ lại (trừ khi chuỗi tiếp theo của bạn phát triển StringBuilder) có lợi hơn so với instantiation.

(Ý kiến ​​của tôi là trái với những gì mọi người khác được đề xuất. Hmm Time. Để benchmark nó.)

Answer 5

Điều thứ hai là khoảng 25% nhanh hơn trong mini-benchmark của tôi.

public class ScratchPad { 

    static String a; 

    public static void main(String[] args) throws Exception { 
     long time = System.currentTimeMillis(); 
     for(int i = 0; i < 10000000; i++) { 
      StringBuilder sb = new StringBuilder(); 
      sb.append("someString"); 
      sb.append("someString2"+i); 
      sb.append("someStrin4g"+i); 
      sb.append("someStr5ing"+i); 
      sb.append("someSt7ring"+i); 
      a = sb.toString(); 
     } 
     System.out.println(System.currentTimeMillis()-time); 
     time = System.currentTimeMillis(); 
     StringBuilder sb = new StringBuilder(); 
     for(int i = 0; i < 10000000; i++) { 
      sb.delete(0, sb.length()); 
      sb.append("someString"); 
      sb.append("someString2"+i); 
      sb.append("someStrin4g"+i); 
      sb.append("someStr5ing"+i); 
      sb.append("someSt7ring"+i); 
      a = sb.toString(); 
     } 
     System.out.println(System.currentTimeMillis()-time); 
    } 
} 

Kết quả:

25265 
17969 

Lưu ý rằng đây là với JRE 1.6.0_07.

---

Dựa trên ý tưởng của Jon Skeet trong chỉnh sửa, đây là phiên bản 2. Kết quả tương tự.

public class ScratchPad { 

    static String a; 

    public static void main(String[] args) throws Exception { 
     long time = System.currentTimeMillis(); 
     StringBuilder sb = new StringBuilder(); 
     for(int i = 0; i < 10000000; i++) { 
      sb.delete(0, sb.length()); 
      sb.append("someString"); 
      sb.append("someString2"); 
      sb.append("someStrin4g"); 
      sb.append("someStr5ing"); 
      sb.append("someSt7ring"); 
      a = sb.toString(); 
     } 
     System.out.println(System.currentTimeMillis()-time); 
     time = System.currentTimeMillis(); 
     for(int i = 0; i < 10000000; i++) { 
      StringBuilder sb2 = new StringBuilder(); 
      sb2.append("someString"); 
      sb2.append("someString2"); 
      sb2.append("someStrin4g"); 
      sb2.append("someStr5ing"); 
      sb2.append("someSt7ring"); 
      a = sb2.toString(); 
     } 
     System.out.println(System.currentTimeMillis()-time); 
    } 
} 

Kết quả:

5016 
7516 

Answer 6

rồi, bây giờ tôi hiểu những gì đang xảy ra, và nó có ý nghĩa.

Tôi đã bị ấn tượng rằng toString chỉ cần vượt qua phần cơ bản char[] thành một công cụ xây dựng chuỗi mà không lấy một bản sao. Sau đó, bản sao sẽ được thực hiện trên thao tác "ghi" tiếp theo (ví dụ: delete). Tôi tin rằng đây là là trường hợp có StringBuffer trong một số phiên bản trước đó. (Không phải bây giờ.) Nhưng không - toString chỉ cần vượt qua mảng (và chỉ mục và chiều dài) để công khai xây dựng String mà mất một bản sao.

Vì vậy, trong trường hợp "tái sử dụng StringBuilder", chúng tôi thực sự tạo một bản sao dữ liệu cho mỗi chuỗi, sử dụng cùng một mảng char trong bộ đệm toàn bộ thời gian. Rõ ràng tạo ra một StringBuilder mới mỗi lần tạo một bộ đệm cơ bản mới - và sau đó bộ đệm đó được sao chép (hơi vô nghĩa, trong trường hợp cụ thể của chúng ta, nhưng được thực hiện vì lý do an toàn) khi tạo một chuỗi mới.

Tất cả điều này dẫn đến phiên bản thứ hai chắc chắn hiệu quả hơn - nhưng đồng thời tôi vẫn cho rằng đó là mã xấu hơn.

Answer 7

Khai báo một lần và chỉ định mỗi lần. Nó là một khái niệm thực dụng hơn và có thể tái sử dụng hơn là một sự tối ưu hóa.

Answer 8

Đầu tiên là tốt hơn cho con người. Nếu thứ hai nhanh hơn một chút trên một số phiên bản của một số JVM, vậy thì sao?

Nếu hiệu suất là quan trọng, bỏ qua StringBuilder và viết của riêng bạn. Nếu bạn là một lập trình viên giỏi và tính đến cách ứng dụng của bạn đang sử dụng chức năng này, bạn sẽ có thể làm cho nó nhanh hơn nữa. Đáng giá? Chắc là không.

Tại sao câu hỏi này được xem là "câu hỏi yêu thích"? Bởi vì tối ưu hóa hiệu suất là rất nhiều niềm vui, không có vấn đề cho dù đó là thực tế hay không.

Answer 9

Vì tôi không nghĩ rằng nó đã được chỉ ra, vì tối ưu hóa được tích hợp vào trình biên dịch Sun Java, tự động tạo StringBuilders (StringBuffers pre-J2SE 5.0) khi thấy chuỗi nối, ví dụ đầu tiên trong câu hỏi là tương đương với:

for (loop condition) { 
    String s = "some string"; 
    . . . 
    s += anotherString; 
    . . . 
    passToMethod(s); 
} 

Cách nào dễ đọc hơn, IMO, cách tiếp cận tốt hơn. Những nỗ lực của bạn để tối ưu hóa có thể dẫn đến lợi ích trong một số nền tảng, nhưng có khả năng mất mát những nền tảng khác.

Nhưng nếu bạn thực sự đang gặp sự cố với hiệu suất thì hãy chắc chắn, tối ưu hóa. Tôi bắt đầu với việc xác định rõ ràng kích thước bộ đệm của StringBuilder, mặc dù, theo Jon Skeet.

Answer 10

nhanh hơn vẫn:

public class ScratchPad { 

    private static String a; 

    public static void main(String[] args) throws Exception { 
     long time = System.currentTimeMillis(); 
     StringBuilder sb = new StringBuilder(128); 

     for(int i = 0; i < 10000000; i++) { 
      // Resetting the string is faster than creating a new object. 
      // Since this is a critical loop, every instruction counts. 
      // 
      sb.setLength(0); 
      sb.append("someString"); 
      sb.append("someString2"); 
      sb.append("someStrin4g"); 
      sb.append("someStr5ing"); 
      sb.append("someSt7ring"); 
      setA(sb.toString()); 
     } 

     System.out.println(System.currentTimeMillis()-time); 
    } 

    private static void setA(String aString) { 
     a = aString; 
    } 
} 

Trong triết lý của việc viết mã rắn, các hoạt động bên của phương pháp này nên được ẩn từ các đối tượng sử dụng phương pháp này. Do đó, nó không có sự khác biệt so với quan điểm của hệ thống cho dù bạn redeclare StringBuilder trong vòng lặp hoặc bên ngoài vòng lặp. Kể từ khi tuyên bố nó bên ngoài vòng lặp là nhanh hơn, và nó không làm cho mã phức tạp hơn để đọc, sau đó tái sử dụng các đối tượng hơn là reinstantiate nó.

Ngay cả khi mã phức tạp hơn và bạn biết chắc chắn rằng sự kiện đối tượng là nút cổ chai, hãy nhận xét nó.

Ba chạy với câu trả lời này:

$ java ScratchPad 
1567 
$ java ScratchPad 
1569 
$ java ScratchPad 
1570 

Ba chạy với câu trả lời khác:

$ java ScratchPad2 
1663 
2231 
$ java ScratchPad2 
1656 
2233 
$ java ScratchPad2 
1658 
2242 

Mặc dù không có ý nghĩa, thiết lập kích thước bộ đệm ban đầu của StringBuilder sẽ cung cấp một lợi nhỏ.

Answer 11

Lý do tại sao thực hiện 'setLength' hoặc 'delete' cải thiện hiệu suất chủ yếu là mã 'học' kích thước phù hợp của bộ đệm và ít hơn để thực hiện cấp phát bộ nhớ. Nói chung, I recommend letting the compiler do the string optimizations. Tuy nhiên, nếu hiệu suất là rất quan trọng, tôi sẽ thường tính toán trước kích thước mong đợi của bộ đệm. Kích thước StringBuilder mặc định là 16 ký tự. Nếu bạn phát triển vượt ra khỏi đó, thì nó phải thay đổi kích thước. Thay đổi kích thước là nơi hiệu suất bị mất. Dưới đây là một điểm chuẩn nhỏ khác minh họa điều này:

private void clear() throws Exception { 
    long time = System.currentTimeMillis(); 
    int maxLength = 0; 
    StringBuilder sb = new StringBuilder(); 

    for(int i = 0; i < 10000000; i++) { 
     // Resetting the string is faster than creating a new object. 
     // Since this is a critical loop, every instruction counts. 
     // 
     sb.setLength(0); 
     sb.append("someString"); 
     sb.append("someString2").append(i); 
     sb.append("someStrin4g").append(i); 
     sb.append("someStr5ing").append(i); 
     sb.append("someSt7ring").append(i); 
     maxLength = Math.max(maxLength, sb.toString().length()); 
    } 

    System.out.println(maxLength); 
    System.out.println("Clear buffer: " + (System.currentTimeMillis()-time)); 
} 

private void preAllocate() throws Exception { 
    long time = System.currentTimeMillis(); 
    int maxLength = 0; 

    for(int i = 0; i < 10000000; i++) { 
     StringBuilder sb = new StringBuilder(82); 
     sb.append("someString"); 
     sb.append("someString2").append(i); 
     sb.append("someStrin4g").append(i); 
     sb.append("someStr5ing").append(i); 
     sb.append("someSt7ring").append(i); 
     maxLength = Math.max(maxLength, sb.toString().length()); 
    } 

    System.out.println(maxLength); 
    System.out.println("Pre allocate: " + (System.currentTimeMillis()-time)); 
} 

public void testBoth() throws Exception { 
    for(int i = 0; i < 5; i++) { 
     clear(); 
     preAllocate(); 
    } 
} 

Kết quả cho thấy việc sử dụng lại đối tượng nhanh hơn khoảng 10% so với kích thước mong muốn.

Answer 12

LOL, lần đầu tiên tôi thấy mọi người so sánh hiệu suất bằng cách kết hợp chuỗi trong StringBuilder. Với mục đích đó, nếu bạn sử dụng "+", nó có thể còn nhanh hơn; D. Mục đích của việc sử dụng StringBuilder để tăng tốc độ truy xuất toàn bộ chuỗi như khái niệm "địa phương".

Trong trường hợp bạn truy xuất một chuỗi giá trị thường xuyên mà không cần thay đổi thường xuyên, Stringbuilder cho phép hiệu năng thu hồi chuỗi cao hơn. Và đó là mục đích của việc sử dụng Stringbuilder .. xin vui lòng không MIS-Kiểm tra mục đích cốt lõi của điều đó ..

Một số người nói, Máy bay bay nhanh hơn. Vì vậy, tôi thử nghiệm nó với chiếc xe đạp của tôi, và thấy rằng máy bay di chuyển chậm hơn. Bạn có biết làm thế nào tôi thiết lập các thiết lập thử nghiệm, D

Answer 13

Không nhanh hơn đáng kể, nhưng từ các thử nghiệm của tôi nó cho thấy trung bình là một vài millis nhanh hơn bằng cách sử dụng 1.6.0_45 64 bit: sử dụng StringBuilder.setLength (0) thay vì StringBuilder.delete():

time = System.currentTimeMillis(); 
StringBuilder sb2 = new StringBuilder(); 
for (int i = 0; i < 10000000; i++) { 
    sb2.append("someString"); 
    sb2.append("someString2"+i); 
    sb2.append("someStrin4g"+i); 
    sb2.append("someStr5ing"+i); 
    sb2.append("someSt7ring"+i); 
    a = sb2.toString(); 
    sb2.setLength(0); 
} 
System.out.println(System.currentTimeMillis()-time); 

Answer 14

Cách nhanh nhất là sử dụng "setLength". Nó sẽ không liên quan đến hoạt động sao chép. Cách tạo StringBuilder mới phải hoàn toàn ra khỏi. Sự chậm chạp của StringBuilder.delete (int int, int end) là vì nó sẽ sao chép mảng một lần nữa cho phần thay đổi kích thước.

System.arraycopy(value, start+len, value, start, count-end); 

Sau đó, StringBuilder.delete() sẽ cập nhật StringBuilder.count thành kích thước mới. Trong khi StringBuilder.setLength() chỉ đơn giản hóa việc cập nhật StringBuilder.count thành kích thước mới.