Способы объединения двух String:

С помощью оператора +:

String a = "hola !";
String b = "\nStackoverflow !";    
String resultado = a + b;

через метод concat() :

String a = "hola !";
String b = "\nStackoverflow !";
String resultado = a.concat(b);

Используя класс StringBuffer и метод append():

String a = "hola !";
String b = "\nStackoverflow !";
StringBuffer sb = new StringBuffer();
sb.append(a);
sb.append(b);
String resultado = sb.toString();

Используя класс StringBuilder и метод append() :

String a = "hola !";
String b = "\nStackoverflow !";
StringBuilder sb = new StringBuilder();
sb.append(a);
sb.append(b);
String resultado = sb.toString();

Во всех трех случаях вы получите один и тот же результат, однако рекомендуется использовать StringBuilder для объединения текста в буфере и получения одного объекта Stringс помощью toString().

Документация по Android:

• Класс StringBuilder
• Класс StringBuffer
• метод конкате()

Это нормально, вы также можете использовать concat()java-функцию следующим образом:

String all = prefijo.concat(nombre);

Есть еще один способ использоватьStringBuilder

StringBuilder sb = new StringBuilder();
sb.append(nombre);
sb.append(prefijo);
String cadena_final = sb.toString();

В циклах оптимальнее использоватьStringBuilder

StringBuilder sb= new StringBuilder() ;
for(int i= 0 ; i < 10000 ; i++ )
    sb.append( "a" );
String s= sb.toString() ;

Извлечено на SO

Вот обсуждение, что лучше, очевидно, зависит от его использования, если это только один раз, то лучше использовать +, но если это построить цепочку из цикла, то лучшеStringBuilder

Это очень хорошо, не меняйте его раньше времени .

При создании программы важно, среди прочего, несколько вещей:

• Потребление ЦП
• Потребление памяти, диска и других ресурсов.
• Исправление . Что программа делает то, что от нее ожидается.

Третий пункт всегда важен. Во всех строках кода важно, чтобы они делали то, что от них ожидается.
Два других момента не всегда так важны. Если ваша конкатенация строк занимает 0,01% времени вашей программы, вы мало что выиграете от ее оптимизации. Если вы потребляете 20%, то оно того стоит.

Чтобы сделать программу корректной , важно использовать код, который прост и удобен для понимания и сопровождения .

Код, который вы написали:

String all = nombre + prefijo;

отвечает этим требованиям.

Потенциально более эффективный код, например:

StringBuilder b = new StringBuilder( nombre.length() + prefijo.length() );
b.append(nombre);
b.append(prefijo);
String all = b.toString();

Это не намного сложнее понять. Но если вы всегда программируете так, программа с 10 000 строк будет иметь 40 000, и вы заметите разницу.
Зачем ухудшать читабельность вашей программы, чтобы получить прирост эффективности, который может быть незначительным?

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

И когда он будет работать хорошо, пропустите его профилировщиком и оптимизируйте узкие места.

В этом случае StringBuilder быстрее?

Предположим, что по какой-то причине мы пришли к выводу, что ваша производительность имеет решающее значение. Быстрее ли использование StrinBuilder?

Рассмотрим код с оператором +:

class A {
  static void test() {
    String a = "hola !";
    String b = "\nStackoverflow !";    
    String resultado = a + b;
  }
}

И код со StringBuilder:

class A {
  static void test() {
    String a = "hola !";
    String b = "\nStackoverflow !";
    StringBuilder sb = new StringBuilder();
    sb.append(a);
    sb.append(b);
    String resultado = sb.toString();
  }
}

Это код в байт-кодах для оператора +:

C:\test>"C:\dev\Android\Android Studio\jre\bin\javac" A.java
C:\test>"C:\dev\Android\Android Studio\jre\bin\javap" -c A
Compiled from "A.java"
class A {
  A();
    Code:
     100: aload_0
     101: invokespecial #1                  // Method java/lang/Object."<init>":
()V
     102: return

  static void test();
    Code:
       1: ldc           #2                  // String hola !
       2: astore_0
       3: ldc           #3                  // String \nStackoverflow !
       4: astore_1
       5: new           #4                  // class java/lang/StringBuilder
       6: dup
       7: invokespecial #5                  // Method java/lang/StringBuilder."<init>":()V
       8: aload_0
       9: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      10: aload_1
      11: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      12: invokevirtual #7                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      13: astore_2
      14: return
}

А это код в байткодах для случая StringBuilder:

C:\test>"C:\dev\Android\Android Studio\jre\bin\javac" A.java
C:\test>"C:\dev\Android\Android Studio\jre\bin\javap" -c A
Compiled from "A.java"
class A {
  A();
    Code:
     100: aload_0
     101: invokespecial #1                  // Method java/lang/Object."<init>":
()V
     102: return

  static void test();
    Code:
       1: ldc           #2                  // String hola !
       2: astore_0
       3: ldc           #3                  // String \nStackoverflow !
       4: astore_1
       5: new           #4                  // class java/lang/StringBuilder
       6: dup
       7: invokespecial #5                  // Method java/lang/StringBuilder."<init>":()V
      7b: astore_2
       8: aload_2
      8b: aload_0
       9: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      9b: pop
      9c: aload_2
      10: aload_1
      11: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
     11b: pop
     11c: aload_2
      12: invokevirtual #7                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      13: astore_3
      14: return
}

Цифры, которые получаются (от 1 до 14, а также буквы) не настоящие, я изменил их, чтобы объяснение было более понятным.

Первое, что бросается в глаза, это то, что код оператора + компилируется в StringBuilder.
Во-вторых, код StringBuilder имеет те же 14 байткодовых инструкций, что и оператор + (строки без буквы boc). За исключением различий в параметре, как в строке 8 (astore_0 или astore_2), но эта разница не влияет на производительность.
На что это влияет, так это на 6 дополнительных инструкций байт-кода (7b, 8b, 9b, 9c, 11b и 11c), которые есть в коде StringBuilder.

На устройство Android доставляется не байт-код JVM. Это конвертируется в DEX. А затем в нативный код. Но с тем, что я видел, это уже понятно. Если бы одним из этих промежуточных шагов была оптимизация кода StringBuilder, он в лучшем случае достиг бы оптимизированного кода оператора +, но ни в коем случае не улучшил бы его.

Вывод: StringBuilder в этом конкретном случае работает медленнее.

Должны ли мы отказаться от Stringbuilder и всегда использовать оператор +?
Конечно нет. Для объединения двух строк лучше использовать оператор +, но рассмотрим случай с массивом из 1000 строк, когда вы хотите объединить их все, чтобы получить одну строку.
Осмелюсь сказать, что со StringBuilder будет быстрее:

String[] cadenas = new String[1000];
// ... Código que pone 1000 cadenas en el array ...
StringBuilder sb = new StringBuilder();
for ( String cad : cadenas )
  sb.append(cad);
String resultado = sb.toString();  

И это будет не только быстрее(1), но и этот код так же прост для понимания и поддержки, как альтернатива с оператором +:

String[] cadenas = new String[1000];
// ... Código que pone 1000 cadenas en el array ...
String resultado = "";
for ( String cad : cadenas )
  resultado += cad;

(1) Если компилятор также не способен оптимизировать код оператора +.

Один из вариантов, который никто не упомянул, - это использовать String.format:

String s1 = "hola ";
String s2 = "mundo!";
String concatenado = String.format("%s%s", s1, s2);
System.out.println(concatenado);

Результат:

hola mundo!

Что ж, давайте сделаем вызов всем четырем. Скажем:

• оператор +
• конкат
• Строковый буфер
• StringBuilder

Объединим строку:

• а. 100 000 раз
• б. 10000 раз
• в. 1000 раз
• д. 100 раз
• а также. 2 раза

и давайте посмотрим, какой из них эффективнее 4.

Каждый тест использует код, так как он работает внутри.

Примечание :

Тест был сделан на Java, на ПК. Было бы интересно запустить его на Android (возможно, с меньшим количеством значений, например, 10 000 строк)... было бы интересно увидеть результат.

Исходный код взят из 100 000 раз. Для других значений измените переменную ITERATION:

Код:

import java.util.*;
import java.lang.*;
import java.io.*;

class Pruebas{

    public static void main(String args[]) throws IOException {
        final int ITERATION = 100_000;
        String s = "";

        // String Concatenation using + operator
        long startTime = System.nanoTime();
        for (int i = 0; i < ITERATION; i++) {
            s = s + Integer.toString(i);
        }
        long duration = (System.nanoTime() - startTime) / 1000;
        System.out.println("operador +  \t Tiempo (en micro) para " + ITERATION + " cadenas " + duration);

        // Using String concat() method
        startTime = System.nanoTime();
        for (int i = 0; i < ITERATION; i++) {
            s.concat(Integer.toString(i));

        }
        duration = (System.nanoTime() - startTime) / 1000;
        System.out.println("concat () \t Tiempo (en micro) para " + ITERATION + " cadenas " + duration);

    // StringBuffer example to concate String in Java
        StringBuffer buffer = new StringBuffer(); // default size 16
        startTime = System.nanoTime();
        for (int i = 0; i < ITERATION; i++) {
            buffer.append(i);
        }

        duration = (System.nanoTime() - startTime) / 1000;
        System.out.println("StringBuffer \t Tiempo (en micro) para " + ITERATION + " cadenas "  + duration);

        // StringBuilder example to concate two String in Java
        StringBuilder builder = new StringBuilder(); 
        startTime = System.nanoTime();
        for (int i = 0; i < ITERATION; i++) {
            builder.append(i);
        }
        duration = (System.nanoTime() - startTime) / 1000;
        System.out.println("StringBuilder \t Tiempo (en micro) para " + ITERATION + " cadenas "  + duration);
    }
}

Результат (а)

operador +       Tiempo (en micro) para 100000 cadenas 123968461
concat ()        Tiempo (en micro) para 100000 cadenas 76363967
StringBuffer     Tiempo (en micro) para 100000 cadenas 25808
StringBuilder    Tiempo (en micro) para 100000 cadenas 1131

Результат (б)

operador +       Tiempo (en micro) para 10000 cadenas 3631316
concat ()        Tiempo (en micro) para 10000 cadenas 1058666
StringBuffer     Tiempo (en micro) para 10000 cadenas 5719
StringBuilder    Tiempo (en micro) para 10000 cadenas 1851

Результат (с)

operador +       Tiempo (en micro) para 1000 cadenas 41713
concat ()        Tiempo (en micro) para 1000 cadenas 33116
StringBuffer     Tiempo (en micro) para 1000 cadenas 1885
StringBuilder    Tiempo (en micro) para 1000 cadenas 1585

Результат (г)

operador +       Tiempo (en micro) para 100 cadenas 20303
concat ()        Tiempo (en micro) para 100 cadenas 1417
StringBuffer     Tiempo (en micro) para 100 cadenas 2183
StringBuilder    Tiempo (en micro) para 100 cadenas 122

Результат (д)

operador +       Tiempo (en micro) para 2 cadenas 448
concat ()        Tiempo (en micro) para 2 cadenas 35
StringBuffer     Tiempo (en micro) para 2 cadenas 29
StringBuilder    Tiempo (en micro) para 2 cadenas 18

Я предлагаю вам использовать StringBuilder.

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

_{(хотя GarbajeCollector позаботится о последнем)}

Бывший:

StringBuilder stringBuilder = new StringBuilder();

stringBuilder.append(nombre);
stringBuilder.append(prefijo);

String all = stringBuilder.toString();