Java: String concat vs StringBuilder - оптимизирован, поэтому что мне делать?

Question

В статье this answer говорится (подразумевает), что конкатенация строк в любом случае оптимизирована для операций StringBuilder, поэтому, когда я пишу свой код, есть ли какие-либо причины для написания кода StringBuilder в источнике? Обратите внимание, что мой вариант использования отличается от вопроса OP, поскольку я конкатенирую/добавляю сотни тысяч строк.

Чтобы сделать себя яснее: я хорошо осведомлен о различиях каждого из них, я просто не знаю, стоит ли на самом деле писать код StringBuilder, потому что он менее читабельный, и когда его якобы более медленный кузен, класс String, автоматически преобразуется в процессе компиляции.

Answer 1

Я думаю, что использование StringBuilder против + действительно зависит от контекста, вы используете его.

В целом с использованием JDK 1.6 и выше компилятор автоматически соединит строки вместе, используя StringBuilder.

String one = "abc"; 
String two = "xyz"; 
String three = one + two; 

будет скомпилирован String three как:

String three = new StringBuilder().append(one).append(two).toString(); 

Это весьма полезно и экономит некоторое время работы. Однако этот процесс не всегда оптимален. Возьмем, к примеру:

String out = ""; 
for(int i = 0; i < 10000 ; i++) { 
    out = out + i; 
} 
return out; 

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

String out = ""; 
for(int i = 0; i < 10000; i++) { 
    out = new StringBuilder().append(out).append(i).toString(); 
} 
return out; 

компилятор оптимизировал внутреннюю петлю, но, конечно, не сделал лучшие возможности оптимизации ,Для того, чтобы улучшить наш код, который мы могли бы использовать:

StringBuilder out = new StringBuilder(); 
for(int i = 0 ; i < 10000; i++) { 
    out.append(i); 
} 
return out.toString(); 

Теперь это более оптимальным, чем компилятор сгенерированный код, так что, безусловно, нужно писать код, используя классы StringBuilder/StringBuffer в тех случаях, когда требуется эффективный код. Текущие компиляторы не очень эффективны при конкатенации строк в цикле, однако это может измениться в будущем.

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

Примечание. Я скомпилировал код с использованием JDK 1.6 и декомпилировал код с помощью программы javap, которая выплевывает байт-код. Его довольно легко интерпретировать и часто полезно использовать при попытке оптимизировать код. Компилятор меняет ваш код за кулисами, поэтому всегда интересно посмотреть, что он делает!

Answer 2

Возможно, я неправильно понял ваш вопрос, но StringBuilder быстрее при добавлении строк. Итак, да, если вы добавляете «сотни тысяч строк», вам определенно следует использовать StringBuilder (или StringBuffer, если вы используете многопоточное приложение).

(Более тщательный ответ в комментариях)

Answer 3

Это зависит от случая, но StringBuilder считается немного быстрее. Если вы выполняете конкатенацию внутри цикла, я бы предложил вам использовать StringBuilder.

В любом случае, я бы посоветовал вам профилировать и сравнивать ваш код (если вы делаете такое массивное приложение).

Будьте осторожны: экземпляры StringBuilder являются изменяемыми и не должны делиться между потоками (если вы действительно не знаете, что делаете.), В отличие от String, которые являются неизменяемыми.

Answer 4

Ключевая фраза в вашем вопросе - «предположительно медленнее». Вам нужно определить, действительно ли это узкое место, а затем посмотреть, что быстрее.

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

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