Home / Questions / 65327
Accepted
PiledroMurcia
Asked: 2020-04-26 06:44:24 +0800 CST 2020-04-26 06:44:24 +0800 CST

如何在Android中连接两个字符串？

  • 772

我想执行两个的连接String：

String nombre = adornoF.getNombre();
String prefijo = ga.getsid();
String all = nombre + prefijo;

只要getNombre()他们getsid()返回一个String.

可以吗还是有更好的方法？

java

7 Answers

  1. Best Answer

    连接两个的方法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();

    在所有 3 种情况下，您都会得到相同的结果，但是作为一个好习惯，最好使用StringBuilder连接缓冲区中的文本并String使用toString().

    安卓文档：

    • 15

  2. 没关系，你也可以concat()像这样使用java函数：

    String all = prefijo.concat(nombre);
    • 7

  3. 还有一种方法是使用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() ;

    在操作系统上提取

    这是更好的讨论显然取决于它的使用，如果它只使用一次则更好，+但如果它是从一个循环构建一个链，那么更好StringBuilder

    • 7

  4. 很好，不要过早的改变它。

    在制作程序时，有几件事很重要，其中包括：

    • CPU消耗
    • 内存、磁盘和其他资源的消耗。
    • 修复。该程序执行预期的操作。

    第三点总是很重要。在所有代码行中，重要的是他们按照对他们的期望去做。
    其他两点并不总是那么重要。如果你的字符串连接消耗了你程序 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），但这种差异不影响性能。
    真正影响的是 StringBuilder 代码具有的 6 个额外字节码指​​令（7b、8b、9b、9c、11b 和 11c）。

    传送到 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) 除非编译器也能够优化 + 运算符代码。

    • 7

  5. 没有人提到的一种选择是使用String.format：

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

    结果：

    hola mundo!
    • 1

  6. 好吧，让我们对所有四个人进行挑战。让我们说：

    • 运算符 +
    • 连接
    • 字符串缓冲区
    • 字符串生成器

    让我们连接一个字符串：

    • 一个。100,000 次
    • 湾。10,000 次
    • C。1,000 次
    • d。100 次
    • 和。2次

    让我们看看哪一个更有效。

    每个测试都使用代码，因为它在内部工作。

    注意：

    测试是在 PC 上用 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

    结果 (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

    结果 (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

    结果(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

    结果（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
    • 0

  7. 我建议你使用StringBuilder.

    java的问题Strings在于它们是不可变的，每次使用它们时都会创建一个对象。对于少数进程，成本无关紧要，但对于大型项目，StringBuilder它可以提供更好的性能，进而减少内存消耗。

    （尽管 GarbajeCollector 会处理后者）

    前任：

    StringBuilder stringBuilder = new StringBuilder();

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

String all = stringBuilder.toString();
    • -2