【问题标题】：How do I concatenate two strings in Java?如何在 Java 中连接两个字符串？
【发布时间】：2011-04-14 19:25:40
【问题描述】：

我正在尝试在 Java 中连接字符串。为什么这不起作用？

public class StackOverflowTest {  
    public static void main(String args[]) {
        int theNumber = 42;
        System.out.println("Your number is " . theNumber . "!");
    }
}

【问题讨论】：

标签： java string-concatenation

【解决方案1】：

您可以使用+ 运算符连接字符串：

System.out.println("Your number is " + theNumber + "!");

theNumber 隐式转换为字符串"42"。

【讨论】：

或者您可以使用String.format 有关 string.formater 的更多详细信息，请查看Formatter 文档。

【解决方案2】：

java中的连接运算符是+，而不是.

Read this（包括所有小节）在您开始之前。试着停止思考 php 的方式；）

为了拓宽您对在 Java 中使用字符串的看法 - 字符串的 + 运算符实际上（由编译器）转换为类似于：

new StringBuilder().append("firstString").append("secondString").toString()

【讨论】：

@Erick Robertson 你错了。重读java.lang.String 的javadoc。在循环内使用+ 效率低下。否则编译器使用StringBuilder
@Erick：你把+ 和+= 混淆了。
哇，这对我来说是新的。它并不总是这样。当我可以用一系列+ 做同样的事情时，我现在将停止显式使用StringBuilder。但是，在跨多行连接字符串时，我仍然会使用它，例如有条件地附加字符串等。谢谢！

【解决方案3】：

这个问题有两个基本答案：

[简单] 使用+ 运算符（字符串连接）。 "your number is" + theNumber + "!"（如其他地方所述）
[不太简单]：使用StringBuilder（或StringBuffer）。

StringBuilder value;
value.append("your number is");
value.append(theNumber);
value.append("!");

value.toString();

我建议不要进行这样的堆叠操作：

new StringBuilder().append("I").append("like to write").append("confusing code");

编辑：从 java 5 开始，字符串连接运算符被编译器转换为 StringBuilder 调用。因此，上述两种方法是平等的。

注意：空间是一种有价值的商品，正如这句话所表明的那样。

警告：下面的示例 1 生成多个 StringBuilder 实例，效率低于下面的示例 2

示例 1

String Blam = one + two;
Blam += three + four;
Blam += five + six;

示例 2

String Blam = one + two + three + four + five + six;

【讨论】：

JavaC 将“+”转换为使用 StringBuilders 请参阅stackoverflow.com/questions/1532461/…
我认为通常不建议猜测编译器如何翻译代码，因为编译器编写者（和优化器）可能会更改过程以实现最大性能，只要它与语义一致语言。
不建议猜测编译器如何翻译代码。但是，从 java 5 开始，java 编译器将字符串 concat 转换为 StringBuilder 调用，这使得我的断言与猜测相反。

【解决方案4】：

开箱即用，您有 3 种方法在您尝试实现时将变量的值注入 String：

1。最简单的方法

您可以在String 和任何对象或原始类型之间简单地使用运算符+，它会自动连接String 和

如果是对象，则String.valueOf(obj)的值对应于String“null”如果obj是null，否则obj.toString()的值。
如果是原始类型，则相当于String.valueOf(<primitive-type>)。

非 null 对象的示例：

Integer theNumber = 42;
System.out.println("Your number is " + theNumber + "!");

输出：

Your number is 42!

null 对象的示例：

Integer theNumber = null;
System.out.println("Your number is " + theNumber + "!");

输出：

Your number is null!

原始类型示例：

int theNumber = 42;
System.out.println("Your number is " + theNumber + "!");

输出：

Your number is 42!

2。显式方式，可能是最有效的方式

您可以使用StringBuilder（或StringBuffer 线程安全的过时对应项）使用append 方法构建您的String。

示例：

int theNumber = 42;
StringBuilder buffer = new StringBuilder()
    .append("Your number is ").append(theNumber).append('!');
System.out.println(buffer.toString()); // or simply System.out.println(buffer)

输出：

Your number is 42!

在幕后，这实际上是最近的 java 编译器如何使用运算符 + 转换所有 String 连接，与以前的方式的唯一区别是您拥有 完全控制 .

确实，编译器将使用 默认构造函数 所以默认容量 (16) 因为他们不知道要构建的 String 的最终长度是多少，这意味着如果最终长度大于16，容量必然会扩大，在性能上是有代价的。

因此，如果您提前知道最终String 的大小将大于16，那么使用这种方法提供更好的初始容量会更有效。例如，在我们的示例中，我们创建了一个长度大于 16 的 String，因此为了获得更好的性能，应该将其重写为 next：

优化示例：

int theNumber = 42;
StringBuilder buffer = new StringBuilder(18)
    .append("Your number is ").append(theNumber).append('!');
System.out.println(buffer)

输出：

Your number is 42!

3。最易读的方式

您可以使用String.format(locale, format, args) 或String.format(format, args) 方法，它们都依赖于Formatter 来构建您的String。这允许您通过使用将被参数值替换的占位符来指定最终String 的格式。

示例：

int theNumber = 42;
System.out.println(String.format("Your number is %d!", theNumber));
// Or if we need to print only we can use printf
System.out.printf("Your number is still %d with printf!%n", theNumber);

输出：

Your number is 42!
Your number is still 42 with printf!

这种方法最有趣的方面是我们清楚地知道最终的String 是什么，因为它更易于阅读，因此更易于维护。

【讨论】：

【解决方案5】：

java 8 方式：

StringJoiner sj1 = new StringJoiner(", ");
String joined = sj1.add("one").add("two").toString();
// one, two
System.out.println(joined);


StringJoiner sj2 = new StringJoiner(", ","{", "}");
String joined2 = sj2.add("Jake").add("John").add("Carl").toString();
// {Jake, John, Carl}
System.out.println(joined2);

【讨论】：

【解决方案6】：

您必须是 PHP 程序员。

使用+ 符号。

System.out.println("Your number is " + theNumber + "!");

【讨论】：

【解决方案7】：

“+”而不是“.”

【讨论】：

【解决方案8】：

使用+ 进行字符串连接。

"Your number is " + theNumber + "!"

【讨论】：

【解决方案9】：

这应该可以工作

public class StackOverflowTest
{  
    public static void main(String args[])
    {
        int theNumber = 42;
        System.out.println("Your number is " + theNumber + "!");
    }
}

【讨论】：

【解决方案10】：

对于两个字符串的精确连接操作，请使用：

file_names = file_names.concat(file_names1);

在你的情况下使用+ 而不是.

【讨论】：

【解决方案11】：

为了获得更好的性能，请使用str1.concat(str2)，其中str1 和str2 是字符串变量。

【讨论】：

【解决方案12】：

在 java 中，连接符号是“+”。如果您在使用 jdbc 时尝试连接两个或三个字符串，请使用：

String u = t1.getString();
String v = t2.getString();
String w = t3.getString();
String X = u + "" + v + "" + w;
st.setString(1, X);

这里的“”仅用于空格。

【讨论】：

【解决方案13】：

`String.join( delimiter , stringA , stringB , … )`

从 Java 8 及更高版本开始，我们可以使用String.join。

警告：您必须传递所有 String 或 CharSequence 对象。所以你的 int 变量 42 不能直接工作。一种替代方法是使用对象而不是原始对象，然后调用 toString。

Integer theNumber = 42;
String output = 
    String                                                   // `String` class in Java 8 and later gained the new `join` method.
    .join(                                                   // Static method on the `String` class. 
        "" ,                                                 // Delimiter.
        "Your number is " , theNumber.toString() , "!" ) ;   // A series of `String` or `CharSequence` objects that you want to join.
    )                                                        // Returns a `String` object of all the objects joined together separated by the delimiter.
;

转储到控制台。

System.out.println( output ) ;

看到这个code run live at IdeOne.com。

【讨论】：

【解决方案14】：

在Java中，连接符号是“+”，而不是“.”。

【讨论】：

【解决方案15】：

“+”不是“.”

但要小心字符串连接。这是一个链接，介绍了IBM DeveloperWorks 的一些想法。

【讨论】：

【解决方案16】：

您可以使用+ 运算符连接字符串：

String a="hello ";
String b="world.";
System.out.println(a+b);

输出：

hello world.

就是这样

【讨论】：

【解决方案17】：

因此，从能够回答的问题中，您可能已经得到了为什么您的 sn-p 无法正常工作的答案。现在，我将就如何有效地做到这一点添加我的建议。在article is a good place，作者谈到了连接字符串的不同方式，并给出了各种结果之间的时间比较结果。

Java 中连接字符串的不同方式

通过使用 + 运算符 (20 + "")
在String类中使用concat方法
使用StringBuffer
通过使用StringBuilder

方法一：

这是一种不推荐的做法。为什么？当您将它与整数和字符一起使用时，您应该非常清楚在附加字符串之前将整数转换为toString()，否则它将把字符处理为 ASCI int's 并在顶部执行加法。

String temp = "" + 200 + 'B';

//This is translated internally into,

new StringBuilder().append( "" ).append( 200 ).append('B').toString();

方法二：

这是内部concat方法的实现

public String concat(String str) {
    int olen = str.length();
    if (olen == 0) {
        return this;
    }
    if (coder() == str.coder()) {
        byte[] val = this.value;
        byte[] oval = str.value;
        int len = val.length + oval.length;
        byte[] buf = Arrays.copyOf(val, len);
        System.arraycopy(oval, 0, buf, val.length, oval.length);
        return new String(buf, coder);
    }
    int len = length();
    byte[] buf = StringUTF16.newBytesFor(len + olen);
    getBytes(buf, 0, UTF16);
    str.getBytes(buf, len, UTF16);
    return new String(buf, UTF16);
}

这每次都会创建一个新缓冲区并将旧内容复制到新分配的缓冲区。因此，当您在更多字符串上执行此操作时，这将太慢。

方法三：

与 (1) 和 (2) 相比，这是线程安全的并且相对较快。这在内部使用StringBuilder，当它为缓冲区分配新内存时（比如说它的当前大小为10），它会增加它的2*size + 2（即22）。因此，当数组变得越来越大时，这确实会表现得更好，因为它不需要每次都为每个append 调用分配缓冲区大小。

    private int newCapacity(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = value.length >> coder;
        int newCapacity = (oldCapacity << 1) + 2;
        if (newCapacity - minCapacity < 0) {
            newCapacity = minCapacity;
        }
        int SAFE_BOUND = MAX_ARRAY_SIZE >> coder;
        return (newCapacity <= 0 || SAFE_BOUND - newCapacity < 0)
            ? hugeCapacity(minCapacity)
            : newCapacity;
    }

    private int hugeCapacity(int minCapacity) {
        int SAFE_BOUND = MAX_ARRAY_SIZE >> coder;
        int UNSAFE_BOUND = Integer.MAX_VALUE >> coder;
        if (UNSAFE_BOUND - minCapacity < 0) { // overflow
            throw new OutOfMemoryError();
        }
        return (minCapacity > SAFE_BOUND)
            ? minCapacity : SAFE_BOUND;
    }

方法四

StringBuilder 将是String 连接中最快的，因为它不是线程安全的。除非你非常确定你的班级使用这个是单吨的，否则我强烈建议不要使用这个。

简而言之，使用StringBuffer 直到您不确定您的代码是否可以被多个线程使用。如果您确定您的课程是单例课程，请继续使用 StringBuilder 进行连接。

【讨论】：

【解决方案18】：

第一种方法：您可以使用“+”号来连接字符串，但这总是在打印中发生。另一种方式：String类包含一个连接两个字符串的方法：string1.concat(string2);

【讨论】：

【解决方案19】：

import com.google.common.base.Joiner;

String delimiter = "";
Joiner.on(delimiter).join(Lists.newArrayList("Your number is ", 47, "!"));

回答操作员的问题可能有点矫枉过正，但了解更复杂的连接操作是件好事。这个 stackoverflow 问题在该领域的一般谷歌搜索中排名很高，很高兴知道。

【讨论】：

【解决方案20】：

您可以使用 stringbuffer、stringbuilder，以及我之前提到的每个人都提到的“+”。我不确定“+”有多快（我认为它对于较短的字符串来说是最快的），但对于更长的时间，我认为构建器和缓冲区大致相等（构建器稍微快一些，因为它不同步）。

【讨论】：

连接运算符被编译器转化为StringBuilder连接，所以它们实际上是等价的。
是这样吗？我不能确定 + 或 stringbuilder 是否更好。

【解决方案21】：

这是一个在不使用第三个变量的情况下读取和连接 2 个字符串的示例：

public class Demo {
    public static void main(String args[]) throws Exception  {
        InputStreamReader r=new InputStreamReader(System.in);     
        BufferedReader br = new BufferedReader(r);
        System.out.println("enter your first string");
        String str1 = br.readLine();
        System.out.println("enter your second string");
        String str2 = br.readLine();
        System.out.println("concatenated string is:" + str1 + str2);
    }
}

【讨论】：

【解决方案22】：

有多种方法可以做到这一点，但 Oracle 和 IBM 表示使用 + 是一种不好的做法，因为基本上每次连接 String 时，最终都会在内存中创建额外的对象。它将占用 JVM 中的额外空间，您的程序可能空间不足或速度变慢。

使用StringBuilder 或StringBuffer 是最好的方法。请查看上面 Nicolas Fillato 的评论，例如与 StringBuffer 相关的评论。

String first = "I eat";  String second = "all the rats."; 
System.out.println(first+second);

【讨论】：

【解决方案23】：

使用“+”符号可以连接字符串。

String a="I"; 
String b="Love."; 
String c="Java.";
System.out.println(a+b+c);

【讨论】：