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

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"));

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

+ оператор

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()все время и добавлять необработанные строки (ваш первый фрагмент кода правильный).

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

Так

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

превращается в

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

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

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

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

String s = s1 + s2; 

к

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

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

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

concatсоздать новую строку так, как +я думаю.

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

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

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

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

+Лучше всего использовать оператор использования , он также прост и удобочитаем.

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

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

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

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

Лично я предпочитаю Strings.format()простой и удобный для чтения однострочный форматтер строк .

String b = "B value";
String d = "D value";
String fullString = String.format("A %s C %s E F", b, d);
// Output: A B value C D value E F

Все ответы довольно хороши и понятны. Но я чувствовал, что изучение других методов конкатенации строк также может помочь, например, Guava Joiner, Streams, String.format и т. Д.

Для получения полной информации о производительности каждого метода конкатенации java-string-concatenation-which-way-is-best .

Вкратце, производительность конкатенации зависит от номера. строк для объединения. Например, для объединения 1-10 строк лучше всего подходят эти методы - StringBuilder, StringBuffer и Plus Operator. А для объединения сотен строк - Guava Joiner, библиотека apache stringsUtils также отлично работает.

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

Спасибо.