Лучше использовать StringBuilder (это - несинхронизируемая версия; когда Вы создаете строки параллельно?) в эти дни, почти в каждом случае, но вот то, что происходит:

, Когда Вы используете + с двумя строками, это компилирует код как это:

String third = first + second;

К чему-то вроде этого:

StringBuilder builder = new StringBuilder( first );
builder.append( second );
third = builder.toString();

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

for( String str : strings ) {
  out += str;
}

В этом случае, новое StringBuilder экземпляр и новое String (новое значение out - String с неизменны) требуются в каждом повторении. Это очень расточительно. При замене этого синглом StringBuilder средства можно просто произвести сингл String и не заполнить "кучу" String с, о которой Вы не заботитесь.

Раздел Оператор объединения строк + из Спецификации языка Java дает Вам еще некоторую справочную информацию о том, почему + оператор может быть настолько медленным.

Я думаю, что самый простой ответ: это быстрее.

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

http://www.sun.com/software/opensource/java/getinvolved.jsp

http://download.java.net/jdk6/latest/archive/

Поскольку Строки приписываемы в Java, каждый раз Вы concanate Строка, новый объект создается в памяти. SpringBuffer используют тот же объект в памяти.

При конкатенации двух строк Вы на самом деле создаете третий Строковый объект в Java. Используя StringBuffer (или StringBuilder в Java 5/6), быстрее, потому что это использует внутренний массив символов для хранения строки, и когда Вы используете один из добавлять (...) методы, это не создает новый Строковый объект. Вместо этого StringBuffer/Buider добавляет внутренний массив.

В простых конкатенациях, это не действительно проблема, связываете ли Вы строки с помощью StringBuffer/Builder или '+' оператор, но при выполнении большого количества конкатенаций строк, Вы будете видеть, что использование StringBuffer/Builder является путем быстрее.

Как сказано, Строковый объект ummutable, означая, как только он создается (см. ниже), он не может быть изменен.

Строка x = новая Строка ("что-то");//или

Строка x = "что-то";

Поэтому, когда Вы пытаетесь к Строковым объектам concanate, значение тех объектов принято и помещено в новый Строковый объект.

, Если Вы вместо этого используете StringBuffer, который изменяем, Вы постоянно добавляете значения к внутреннему списку символа (примитивы), которые могут быть расширены или усеченные для установки необходимому значению. Никакие новые объекты не создаются, только новый символ создается/удаляется при необходимости для содержания значений.

Поскольку Строки неизменны, каждый вызов к +, оператор создает новый Строковый объект и копирует Строковые данные в новую Строку. Начиная с копирования Строки занимает время линейный в длине Строки, последовательность N звонит в + результаты оператора в O (N <глоток> 2 ) время выполнения (квадратичный).

С другой стороны, так как StringBuffer изменяем, он не должен копировать Строку каждый раз, когда Вы выполняете Добавление (), таким образом, последовательность N Добавляет (), вызовы берут O (N) (линейное) время. Это только имеет значительное значение во времени выполнения при добавлении большого количества Строк вместе.

Для конкатенации двух строковых использований '+' новая строка должна быть выделена с пространством для обеих строк, и затем данными, скопированными с обеих строк. StringBuffer оптимизирован для конкатенации и выделяет больше места, чем необходимый первоначально. При конкатенации новой строки, в большинстве случаев, символы могут просто быть скопированы до конца существующего строкового буфера.
Для конкатенации двух строк, '+' оператор будет, вероятно, иметь меньше служебным, но поскольку Вы связываете больше строк, StringBuffer выйдет вперед, с помощью меньшего количества выделений памяти и меньшего количества копирования данных.

Класс StringBuffer поддерживает массив символов для содержания содержания строк, которые Вы связываете, тогда как + метод создает новую строку каждый раз его названный и добавляет эти два параметра (param1 + param2).

StringBuffer быстрее, потому что 1. это могло бы быть в состоянии использовать свой уже существующий массив для concat/store все строки. 2. даже если они не помещаются в массив, быстрее для выделения большего вспомогательного массива затем для генерации новых Строковых объектов для каждого воскрешения.

AFAIK это зависит от версии JVM в версиях до 1,5 использований "+" или "+ =" на самом деле, скопировал целую строку каждый раз.

Остерегаются, то использование + = на самом деле выделяет новую копию строки.

, Как был указан с помощью + в циклах, включает копирование.

, Когда строки, которые связываются, являются константами времени компиляции, там конкатенировал во время компиляции, таким образом

String foo = "a" + "b" + "c";

Имеет, компилируется в:

String foo = "abc"; 

Java поворачивает string1 + string2 в конструкцию StringBuffer, добавьте (), и toString (). Это имеет смысл.

Однако в Java 1.4 и ранее, это сделало бы это для каждый + оператор в операторе отдельно . Это означало, что, делая + b + c приведет к два конструкции StringBuffer с два toString () вызовы. Если бы у Вас была длинная строка concats, это превратилось бы в реальную путаницу. Выполнение его самостоятельно означало, что Вы могли управлять этим и сделать это правильно.

Java 5.0 и выше, кажется, делает это более разумно, таким образом, это - меньше проблемы и является, конечно, менее подробным.

В некоторых случаях это является устаревшим из-за оптимизаций, выполненных компилятором, но общий вопрос то, что код как:

string myString="";
for(int i=0;i<x;i++)
{
    myString += "x";
}

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

1. создают строковый объект из длины 1 и оценивают "x"
2. , Создают новый строковый объект размера 2, копируют старую строку "x" в него, добавляют, что "x" в положении 2.
3. Создают новый строковый объект размера 3, копируют старую строку "xx" в него, добавляют "x" в положении 3.
4. ... и так далее

, Как Вы видите, каждое повторение должно скопировать еще один символ, приводящий к нам работающий 1+2+3+4+5 +... +N операции каждый цикл. Это - O (n^2) операция. Если бы однако мы знали заранее, что нам только были нужны символы N, мы могли сделать это в единственном выделении с копией просто символов N от строк, которые мы использовали - простой O (n) операция.

StringBuffer/StringBuilder избегают этого, потому что они изменяемы, и так не должны продолжать копировать те же данные много раз (пока существует пространство для копирования в в их внутреннем буфере). Они стараются не выполнять выделение и копируют пропорциональный количеству, добавляет сделанный over-allocing, их буфер пропорцией его текущего размера, давая амортизировал O (1) добавление.

Однако, который стоит отметить, что часто компилятор будет в состоянии оптимизировать код в стиль StringBuilder (или лучше - так как это может выполнить сворачивание констант и т.д.), автоматически.

Я думаю, что данный jdk1.5 (или больше) и Ваша конкатенация ориентировано на многопотоковое исполнение, необходимо использовать StringBuilder вместо StringBuffer http://java4ever.blogspot.com/2007/03/string-vs-stringbuffer-vs-stringbuilder.html Что касается усилений в скорости: http://www.about280.com/stringtest.html

Лично, который я кодировал бы для удобочитаемости, поэтому если Вы не находите, что конкатенация строк делает Ваш код значительно медленнее, останьтесь с тем, какой бы ни метод делает Ваш код более читаемым.

Под капотом это на самом деле создает и добавляет к StringBuffer, звоня toString () на результате. Таким образом, это на самом деле не имеет значения, который Вы больше используете.

Так

String s = "a" + "b" + "c";

становится

String s = new StringBuffer().append("a").append("b").append("c").toString();

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

Не нужно быть быстрее, чем другой. Это не было верно перед Java 1.4.2, потому что при конкатенации больше чем двух строк с помощью "+" оператор, промежуточное звено String объекты будут созданы во время процесса создания заключительной строки.

Однако как JavaDoc для состояний StringBuffer, по крайней мере, начиная с Java 1.4.2 использования "+" оператор компилирует вниз в создание StringBuffer и append() луг много строк к нему. Так никакое различие, по-видимому.

Однако быть осторожным при использовании добавления строки для другой внутренней части цикл! Например:

String myString = "";

for (String s : listOfStrings) {
  // Be careful! You're creating one intermediate String object
  // for every iteration on the list (this is costly!)
  myString += s;
}

Имеют в виду, однако, что обычно конкатенация нескольких строк с "+" является более чистой, чем append() луг их всех.

Для простых конкатенаций как:

String s = "a" + "b" + "c";

довольно бессмысленно использовать StringBuffer - в качестве [1 110], jodonnell указал, что это будет энергично переведено в:

String s = new StringBuffer().append("a").append("b").append("c").toString();

String s = "";
for (int i = 0; i < 10; i++) {
    s = s + Integer.toString(i);
}

StringBuffer sb = new StringBuffer();
for (int i = 0; i < 10; i++) {
    sb.append(i);
}