Лучшие практики/производительность: смешение StringBuilder.append с String.concat

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

StringBuilder sb = new StringBuilder("AAAAAAAAAAAAA")
    .append(B_String).append("CCCCCCCCCCC").append(D_String)
    .append("EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE")
    .append("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");

Это способ сделать это? Из этого сообщения я заметил, что оператор + в Strings создает новый экземпляр StringBuilder, объединяет операнды и возвращает преобразование String, которое кажется много больше работы, чем просто вызов .append(); так что если это правда, то это не может быть и речи. Но как насчет String.concat()? Правильно ли использовать .append() для каждой конкатенации? Или просто для переменных, а литералы можно добавить с помощью .concat()?

StringBuilder sb = new StringBuilder("AAAAAAAAAAAAA")
    .append(B_String.concat("CCCCCCCCCCC")).append(D_String
    .concat("EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE")
    .concat("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"));

Каковы общие правила наилучшей практики и производительности для этих ситуаций? Является ли мое предположение правильным на +, и его действительно просто не использовать?

Ответ 1

`+` оператор

String s = s1 + s2

За кулисами это переводится на:

String s = new StringBuilder(s1).append(s2).toString();

Представьте себе, сколько дополнительной работы он добавляет, если у вас s1 + s2 здесь:

stringBuilder.append(s1 + s2)

вместо:

stringBuilder.append(s1).append(s2)

Несколько строк с `+`

Стоит отметить, что:

String s = s1 + s2 + s3 + ... +sN

переводится на:

String s = new StringBuilder(s1).append(s2).append(s3)...apend(sN).toString();

`concat()`

String s = s1.concat(s2);

String создает массив char[], который может соответствовать как s1, так и s2. Копирует s1 и s2 содержимое в этот новый массив. На самом деле требуется меньше работы, чем оператор +.

`StringBuilder.append()`

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

stringBuilder.append(s1.concat(s2))

также плохо работает, потому что s1.concat(s2) создает дополнительный массив char[] и копирует s1 и s2 ему только для того, чтобы скопировать это новое содержимое массива в внутренний StringBuilder char[].

При этом вы должны использовать append() все время и добавлять необработанные строки (ваш первый фрагмент кода верен).

Ответ 2

Компилятор оптимизирует + конкатенацию.

int a = 1;
String s = "Hello " + a;

преобразуется в

new StringBuilder().append("Hello ").append(1);

Здесь есть отличная тема , объясняющая, почему вы должны использовать оператор +.

Ответ 3

Вы всегда должны использовать append.

concat создайте новую строку, так что мне нравится +.

Если вы concat или используете + с 2 финальной строкой, JVM может сделать оптимизацию, так что она будет такой же, как при добавлении в этом случае.

Ответ 4

Оптимизация выполняется автоматически компилятором.

Компилятор Java2 автоматически преобразует следующее:

String s = s1 + s2;

String s = (new StringBuffer()).append(s1).append(s2).toString();

Взято прямо из Java Best Practices на веб-сайте Oracles.

Ответ 5

Если вы конкатцируете ровно две строки, используйте String.concat(создает новую String, создавая новый char -array, который подходит для обеих строк и копирует в него как строки, так и char).

Если вы выполняете несколько (более двух) строк в одной строке, используйте + или StringBuilder.append, это не имеет значения, поскольку компилятор преобразует + в StringBuilder.append. Это полезно для нескольких строк, поскольку он поддерживает один массив char, который растет по мере необходимости.

Если вы объединяете несколько строк над несколькими строками, создайте один StringBuilder и используйте метод append. В конце, когда вы закончите добавление строк в StringBuilder, используйте его .toString() - метод для создания строки из него. Для concatting в нескольких строках это быстрее, чем второй метод, поскольку второй метод создавал новый StringBuilder в каждой строке, добавлял строки и затем возвращал String, в то время как третий метод использует только один StringBuilder для всего.

Ответ 6

Использовать оператор + - лучшая практика, он также прост и читабельен.

Язык Java обеспечивает специальную поддержку для строки оператор конкатенации (+), а для преобразования других объектов в строки. Конкатенация строк осуществляется через StringBuilder (или StringBuffer) и его метод добавления.

Официальный документ: https://docs.oracle.com/javase/8/docs/api/java/lang/String.html

Ответ 7

в байтовом коде уровень не отличается, и мы не ставим под угрозу эффективность там. В случае выполнения уровня байтового кода он должен пройти через метод перегрузки in-inline для +, вызвав append. то на уровне языка ассемблера (Java написан на C и C создает сборки, похожие на сборку, будет дополнительный вызов регистра для хранения + вызова метода в стеке и будет добавлен дополнительный push. (на самом деле кросс-компилятор может оптимизировать + оператор звоните, в этом случае не делая различий с эффективностью.)

Хорошей практикой является один способ повысить удобочитаемость.:)