Еще раз на строку append vs concat vs +

Может быть, я раскалываю волосы, но мне было интересно в следующем случае:

String newString = a + b + c;  //case 1


String newString = a.concat(b).concat(c);   //case 2

StringBuilder newString = new StringBuilder(); //case 3
newString.append(a);
newString.append(b);    
newString.append(c);

Какой из них лучше всего использовать?

Я имею в виду .

Прочитав об этом, в других сообщениях говорится, что случай 3 - это не то, что оптимальная производительность мудрая, другие, что случай 1 закончится в случае 3 и т.д.

Чтобы быть более конкретным.

Например, все в порядке, какой стиль больше подходит для просмотра от другого программиста, если вам нужно было сохранить его код?

Или, что вы считаете более эффективным для программирования?
Или вы думаете, что быстрее и т.д.

Я не знаю, как еще это выразить.

Ответ, например, случай 3 может быть быстрее, но подавляющее большинство программистов предпочитают случай 1, потому что он наиболее читабельный, также принимается, если он каким-то образом хорошо разработан

Ответ 1

Случай 1 является кратким, четко выражает намерение и эквивалентен случаю 3.

Случай 2 менее эффективен, а также менее читабельен.

Случай 3 почти такой же эффективный, как и в случае 1, но дольше и менее читаем.

Использование случая 3 лучше использовать, когда вам нужно конкатенировать в цикле. В противном случае компилятор компилирует случай 1 в случай 3 (за исключением того, что он строит StringBuilder с new StringBuilder(a)), что делает его еще более эффективным, чем ваш случай 3).

Ответ 2

Случай 3 является наиболее эффективной формой, но JVM преобразует случай 1 в случай 3.

Но я считаю, что случай 2 является наихудшим, он не такой читабельный, как случай 1, а не как исполняемый как случай 3.

Если вы хотите конкатцировать строку в цикле, просто используйте случай 3, вы можете легко проверить прирост производительности, но если он не находится в цикле (или вы не добавляете много строк в последовательности), они почти то же самое.

Случаями, которые вы не должны использовать оператор +, являются:

String a = "";
for (String x : theStrings) {
    a += x;
}

или

String a = b + c;
a = a + d;
a = a + e;
a = a + f;

Ответ 3

Случай 3 лучше в большинстве аспектов. В случае 3 вы не создаете 3 строковых объекта. Из-за неизменяемости строки 2 будут иметь накладные расходы на создание строкового объекта для каждого + (или) concat.

EDIT: перечитайте документ и согласитесь с большинством комментариев, случай 1 - case3.

Ответ 4

Для простых случаев использование + явно более читаемо.

Для редких более сложных случаев StringBuilder имеет смысл. Если вы разделяете строки, то + может быстро перетащить производительность. Петли идут от O (n) до O (n ^ 2) - не проблема, если n мало, но большая проблема, если n может быть большим в неудобных обстоятельствах (возможно, когда вы делаете что-то критическое или когда кто-то злонамерен).

В отличие от других ответов, если у вас есть только три строки, concat может быть победителем. Я умник? Нет. Рассмотрим два других варианта. Вы создаете объект StringBuilder с массивом. При добавлении строк может потребоваться замена массива, и у вас могут быть нечетные биты, оставшиеся в конце массива (например, определенная степень детализации для распределения, поэтому несколько дополнительных char могут или не могут увеличить использование памяти). Вы можете вычислить необходимую емкость, если ненавидите всех, кто читает ваш код. Наилучший случай, два массива (один для StringBuilder, один для String (без совместного использования в течение последних восьми лет)) каждый размер текста результата и два других объекта (StringBuilder и String). Теперь для concat вы выделите объекты String с двумя массивами, но первый массив будет c.length() короче. Это победа! Ну, не для удобочитаемости.

Отказ от ответственности: JVM может выполнять дикую оптимизацию, включая распределение стека после анализа эвакуации и специальную оболочку основных классов. Они с большей вероятностью оптимизируют общий и простой код, чем код с обфускацией.