The ways to concatenate two Stringare:

Using the operator +:

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

via the concat() method :

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

Using the StringBuffer class and the append() method:

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

Using the StringBuilder class, and the append() method :

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

In all 3 cases you would get the same result, however as a good practice it is best to use StringBuilder to concatenate the text in the buffer and get a single object Stringusing toString().

Android Documentation:

• StringBuilder class
• StringBuffer class
• concate() method

That's fine, you can also spend the concat()java function like this:

String all = prefijo.concat(nombre);

There is another way is to useStringBuilder

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

In loops it is more optimal to useStringBuilder

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

Extracted on OS

Here is the discussion which is better obviously depends on its use, if it is only once then better to use +but if it is to build a chain from a loop, then betterStringBuilder

It's very good, don't change it prematurely .

When making a program there are several things that are important, among others:

• CPU consumption
• The consumption of memory, disk and other resources.
• The fix . That the program does what is expected of it.

The third point is always important. In all lines of code it is important that they do what is expected of them.
The other two points are not always as important. If your concatenation of strings consumes 0.01% of the time of your program, you will gain little by optimizing it. If you consume 20% then it is worth it.

To make a program correct it is important to use code that is simple and easy to understand and maintain .

The code you have written:

String all = nombre + prefijo;

meets those requirements.

Potentially more efficient code like:

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

It's not much harder to understand. But if you always program like this, a program with 10,000 lines will have 40,000 and there you will notice the difference.
Why hurt the readability of your program to gain an efficiency gain that might be negligible?

Conclusion: strive to keep your code simple, maintainable, and correct.

And when it works well, pass it a profiler and optimize the bottlenecks.

Is StringBuilder faster in this case?

Let's assume that, for whatever reason, we've come to the conclusion that your performance is critical. Is using StrinBuilder faster?

Let's consider the code with the + operator:

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

And the code with 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();
  }
}

This is the code in bytecodes for the case of the + operator:

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
}

And this is the code in bytecodes for the StringBuilder case:

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
}

The numbers that come out (from 1 to 14, and those of the letters) are not real, I have modified them to make the explanation easier to understand.

The first thing that stands out is that the + operator code is compiled to a StringBuilder.
The second thing is that the StringBuilder code has the same 14 bytcode instructions as the + operator (the lines without the letter boc). Except for differences in the parameter, as in line 8 (astore_0 or astore_2), but this difference does not affect performance.
What it does affect is the 6 extra bytecode instructions (7b, 8b, 9b, 9c, 11b and 11c) that the StringBuilder code has.

It is not JVM bytecode that is delivered to the Android device. This converts to DEX. And then to native code. But with what I have seen, it is already clear. If one of these intermediate steps were to optimize the StringBuilder code, it would reach the optimized + operator code at most, but in no case would it improve it.

Conclusion: StringBuilder is slower in this particular case.

Should we disown Stringbuilder and always use the + operator?
Of course not. To concatenate two strings the + operator is better, but consider the case of an array of 1000 strings where you want to concatenate them all to make a single string.
I would dare to say that with StringBuilder it will be faster:

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

And not only will it be faster(1) but that code is also just as easy to understand and maintain as the alternative with the + operator:

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

(1) Unless the compiler is also capable of optimizing the + operator code.

One option that no one has mentioned is to use String.format:

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

Result:

hola mundo!

Well, let's do a challenge to all four. Let's say to:

• operator +
• concat
• StringBuffer
• StringBuilder

Let us concatenate a string:

• a. 100,000 times
• b. 10,000 times
• c. 1,000 times
• d. 100 times
• and. 2 times

and let's see which one is more efficient of the 4.

Each test uses the code as it works internally.

Note :

The test has been done in Java, on a PC. It would be interesting to run it on Android (perhaps with fewer values, eg 10,000 strings)... it would be interesting to see the result.

The original code is from the 100,000 times. For other values ​​change the variable ITERATION:

Code:

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

Result (a)

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

Result (b)

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

Result (c)

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

Result (d)

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

Result (e)

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

What I suggest is that you use StringBuilder.

The problem with Stringsjava is that they are immutable and every time you work with them it creates an object. With few processes, the cost is irrelevant, but with a large project, StringBuilderit gives better performance and, in turn, less memory consumption.

_{(although the GarbajeCollector will already take care of the latter)}

Ex:

StringBuilder stringBuilder = new StringBuilder();

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

String all = stringBuilder.toString();