Вы можете использовать оператор '+' для объединения двух или более строк, это самый простой способ выполнить работу. Например, "One" + "Two" создаст объект String "OneTwo". Вы можете использовать этот оператор для объединения по крайней мере двух строк, например: "ab"+"cde"+fghi" даст "abcdefghi", а также вы можете использовать строковые переменные.
Эта операция преобразуется компилятором в:

new StringBuilder().append("string1").append("string2").toString()

Эта программа объединяет две строки:

public class Concatenation_string {
 public static void main(String[] args) {
 String s1 = "string1"; 
 Строка s2 = "string2"; 
 
 Строка s1s2 = concatenation_strings_java(s1, s2); 
 System.out.println(s1s2); 
 }
 
 public static Строка concatenation_strings_java (Строка s1, Строка s2) {
 return s1+s2; 
 }
}

Runtime:

string1chain2

Конкатенировать строки с помощью метода String.concat()

Этот метод объединяет одну строку в конце другой. Метод возвращает String со значением String, переданным в объединенном методе, с концом String, используемого для вызова этого метода.

public String concat(String s)

Example:

public class Concatenation_string {
 public static void main(String[] args) {< br /> String s = "Я один"; 
 s = s.concat(" программист"); 
 System.out.println(s); 
 }
}

Runtime:

Я программист

Разница между оператором '+' и методом String.concat()

Чтобы иметь возможность различать разницу между оператором '+' и concat(), мы будем работать с практическим примером.

a+=b
a.concat(b)

Во-первых, есть небольшая разница в семантике. Если a равно null, затем a.concat(b) запускает NullPointerException, но параметр '+' в операторе a+=b обрабатывает значение a даже если это null. Кроме того, метод concat() принимает только значения String, в то время как оператор '+' преобразует значение в String( используя toString() ). Можно сказать, что метод concat() является более строгим в том смысле, что он принимает.

Вы можете написать этот код и посмотреть, что вы получите в output:

public static void main(String[] args) {
 String s = null; 
 s = s.concat(" программист"); 
 System.out.println(s); 
}

Во время выполнения у вас должно быть следующее:

Исключение в потоке "main" java.lang.NullPointerException
 в Concatenation_string.main(Concatenation_string.java:5)

Тот же пример с оператором '+':

public static void main(String[] args) {
 String s = null; 
 s = s + программист; 
 System.out.println(s); 
}

У вас должен получиться следующий результат:

nullprogrammer

Итак, как мы уже говорили ранее, оператор '+' эквивалентно:

a = new StringBuilder()
 .append(a)
 .append(b)
 .toString(); 

Сцепить строки с помощью StringBuffer и StringBuilder

Это средство конкатенации снижает затраты памяти и времени, так как не генерирует объекты String. На самом деле, вы всегда должны использовать StringBuilder вместо StringBuffer, потому что он имеет ту же функциональность, но без синхронизации, что означает более быструю работу. Использование StringBuffer или StringBuilder также приводит к структурированному коду, как показано ниже:

String result = new StringBuilder(15).append(name).append(" ").append(firstname).toString(); 

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

Вот пример java-программы, которая покажет вам, как объединить строку с помощью StringBuilder и StringBuffer.

public static void main(String[] args) {
 String court ="Court of"; 
 Строка module_math ="math"; 
 
 /* StringBuilder */
 String module_res = "networks"; 
 int length = court.length()+module_math.length(); 
 StringBuilder sb = new StringBuilder(length); 
 sb.append(court).append(module_math); 
 Строка res = sb.toString(); 
 System.out.println(res); 
 
 /* StringBuilder */
 length = court.length()+module_math.length(); 
 StringBuffer sBuffer = new StringBuffer(length); 
 sb.append(" и").append(court).append(module_res); 
 res = sb.toString(); 
 System.out.println(res); 
}

Output:

 Math Courtyard
 Математический двор и сеть Courtyard

Производительность конкатенации строк в Java

Понятно, что самый простой и быстрый способ конкатенации строк - это использование оператора '+' И это очень хорошо работает, когда у вас есть только две строки, но если вам нужно объединить тысячи строк и особенно внутри цикла, то производительность снизится с оператором '+'. Причиной низкой производительности является создание временных пакетов для объектов String. Если в вашей программе много строк, вы можете увидеть результаты ниже, которые показывают, что лучший способ крупномасштабной конкатенации - использовать класс StringBuilder. Эта статистика была сделана в 64-битной среде Windows 7, процессоре Core 2 Duo (2,53 ГГц) с 4 ГБ оперативной памяти.

public static void main(String[] args) {
 int nb_op=10000; 
 Строка s=""; 
 
 double t1,t2,time; 
 t1= System.currentTimeMillis(); 
 for(int i = 0 ; i < nb_op; i++)
 s += "*"; 
 t2 = System.currentTimeMillis(); 
 время = t2-t1; 
 System.out.println("+: "+time); 
 
 s=""; 
 t1= System.currentTimeMillis(); 
 for(int i = 0 ; i < nb_op; i++)
 s.concat("*"); 
 t2 = System.currentTimeMillis(); 
 время = t2-t1; 
 System.out.println("concat: "+time); 
 
 StringBuilder sb=new StringBuilder(); 
 t1= System.currentTimeMillis(); 
 for(int i = 0 ; i < nb_op; i++)
 sb.append("*"); 
 t2 = System.currentTimeMillis(); 
 время = t2-t1; 
 System.out.println("StringBuilder: "+time); 
 
 StringBuffer sBuffer=new StringBuffer(); 
 t1= System.currentTimeMillis(); 
 for(int i = 0 ; i < nb_op; i++)
 sBuffer.append("*"); 
 t2 = System.currentTimeMillis(); 
 время = t2-t1; 
 System.out.println("StringBuffer: "+time); 
}

Результаты для 10000 операций конкатенации:

+: 180.0
concat: 13.0
StringBuilder: 2.0
StringBuffer: 4.0

Время в миллисекундах на 10000 операций

Еще один график, показывающий достигнутое время в зависимости от количества операций:


Первое впечатление потрясающее! Здесь мы сразу замечаем, что время, достигнутое оператором '+', пропорционально количеству операций конкатенации и он сделал десять секунд для 100000 операций. Так что оператор «+» — очень плохой выбор при работе над масштабным проектом. concat, StringBuilder и StringBuffer невидимы для оператора '+', но в таблице статистики видно, что StringBiulder занял меньше времени.

Метод  concat()  быстрый. Тем не менее, конкатенация нескольких строк выполняется быстрее с помощью метода StringBuilder с точки зрения производительности.

Исходный код для String и StringBuilder доступен в Sun JDK. Вы можете видеть, что вы строите танковую плату. Он очень быстро выделяет память.

Помните:

• Никогда не используйте оператор + в цикле.
• Всегда используйте StringBuilder для конкатенации нескольких строк.
• Всегда инициализируйте размер StringBuilder.

Ссылки:
Java - Строка concat() Method
Конкатенация строк: concat() vs + operator
Java - Строковый буфер append() Method