来自Perl，我肯定错过了“here-document”在源代码中创建多行字符串的方法：
$string = <<"EOF" # create a three-line string
text
text
text
EOF
在Java中，我必须在每一行都有繁琐的引号和加号，因为我从头开始连接多行字符串。
有哪些更好的选择？在属性文件中定义我的字符串？
编辑：两个答案说StringBuilder.append（）优于加号表示法。任何人都可以详细说明他们为什么这么认为？它看起来并不比我更好。我正在寻找一种方法，即多行字符串不是一流的语言结构，这意味着我绝对不希望用方法调用替换第一类语言结构（字符串连接加上）。
编辑：为了进一步澄清我的问题，我根本不关心表现。我担心可维护性和设计问题。
Stephen Colebourne创建了一个用于在Java 7中添加多行字符串的proposal。
此外，Groovy已经支持multi-line strings。
在IntelliJ IDE中，您只需键入：
""
然后将光标放在引号内并粘贴您的字符串。 IDE将它扩展为多个连接行。
JEP 355: Text Blocks (Preview)旨在涵盖此功能，它目前将JDK 13作为预览功能。允许写下这样的东西：
String s = """
text
text
text
""";
在此JEP之前，在JDK12中，JEP 326: Raw String Literals旨在实现类似功能，但它最终被撤销。
遗憾的是，Java没有多行字符串文字。您必须连接字符串文字（使用+或StringBuilder是两种最常用的方法）或从单独的文件中读取字符串。
对于大型多行字符串文字，我倾向于使用单独的文件并使用getResourceAsStream()（Class类的方法）读取它。这使您可以轻松找到该文件，因为您不必担心当前目录与安装代码的位置。它还使包装更容易，因为您实际上可以将文件存储在jar文件中。
假设你在一个名为Foo的类中。做这样的事情：
Reader r = new InputStreamReader(Foo.class.getResourceAsStream("filename"), "UTF-8");
String s = Utils.readAll(r);
另一个令人烦恼的是，Java没有标准“将此Reader中的所有文本读入字符串”方法。这写起来很容易：
public static String readAll(Reader input) {
StringBuilder sb = new StringBuilder();
char[] buffer = new char[4096];
int charsRead;
while ((charsRead = input.read(buffer)) >= 0) {
sb.append(buffer, 0, charsRead);
}
input.close();
return sb.toString();
}
String newline = System.getProperty ("line.separator");
string1 + newline + string2 + newline + string3
但是，最好的选择是使用String.format
String multilineString = String.format("%s\n%s\n%s\n",line1,line2,line3);
由于Java本身不支持多行字符串，因此现在唯一的方法是使用上述技术之一来破解它。我使用上面提到的一些技巧构建了以下Python脚本：
import sys
import string
import os
print 'new String('
for line in sys.stdin:
one = string.replace(line, '"', '\\"').rstrip(os.linesep)
print ' + "' + one + ' "'
print ')'
将它放在名为javastringify.py的文件中，并将您的字符串放在mystring.txt文件中，并按如下方式运行：
cat mystring.txt | python javastringify.py
然后，您可以复制输出并将其粘贴到编辑器中。
根据需要修改它以处理任何特殊情况，但这适用于我的需要。希望这可以帮助！
您可以使用与java兼容的scala-code，并允许使用“”“括起来的多行字符串：
package foobar
object SWrap {
def bar = """John said: "This is
a test
a bloody test,
my dear." and closed the door."""
}
（注意字符串中的引号）和java：
String s2 = foobar.SWrap.bar ();
这是否更舒服......？
另一种方法，如果你经常处理长文本，它应放在你的源代码中，可能是一个脚本，它从外部文件获取文本，并将其作为multiline-java-String包装如下：
sed '1s/^/String s = \"/;2,$s/^/\t+ "/;2,$s/$/"/' file > file.java
这样您就可以轻松地将其剪切并粘贴到源中。
您可以使用单独的方法连接附加内容，例如：
public static String multilineString(String... lines){
StringBuilder sb = new StringBuilder();
for(String s : lines){
sb.append(s);
sb.append ('\n');
}
return sb.toString();
}
无论哪种方式，更喜欢StringBuilder到加号表示法。
实际上，以下是迄今为止我见过的最干净的实现。它使用注释将注释转换为字符串变量...
/**
<html>
<head/>
<body>
<p>
Hello<br/>
Multiline<br/>
World<br/>
</p>
</body>
</html>
*/
@Multiline
private static String html;
因此，最终结果是变量html包含多行字符串。没有引号，没有加号，没有逗号，只是纯粹的字符串。
此解决方案可从以下URL ... http://www.adrianwalker.org/2011/12/java-multiline-string.html获得
希望有所帮助！
见Java Stringfier。如果需要，将文本转换为StringBuilder java块转义。
我还没有看到答案的另一种选择是java.io.PrintWriter。
StringWriter stringWriter = new StringWriter();
PrintWriter writer = new PrintWriter(stringWriter);
writer.println("It was the best of times, it was the worst of times");
writer.println("it was the age of wisdom, it was the age of foolishness,");
writer.println("it was the epoch of belief, it was the epoch of incredulity,");
writer.println("it was the season of Light, it was the season of Darkness,");
writer.println("it was the spring of hope, it was the winter of despair,");
writer.println("we had everything before us, we had nothing before us");
String string = stringWriter.toString();
此外，java.io.BufferedWriter有newLine()方法的事实没有提到。
听起来你想要做一个多线文字，这在Java中是不存在的。
你最好的选择是将+组合在一起的字符串。人们提到的其他一些选项（StringBuilder，String.format，String.join）只有在你开始使用字符串数组时才会更好。
考虑一下：
String s = "It was the best of times, it was the worst of times,\n"
+ "it was the age of wisdom, it was the age of foolishness,\n"
+ "it was the epoch of belief, it was the epoch of incredulity,\n"
+ "it was the season of Light, it was the season of Darkness,\n"
+ "it was the spring of hope, it was the winter of despair,\n"
+ "we had everything before us, we had nothing before us";
与StringBuilder：
String s = new StringBuilder()
.append("It was the best of times, it was the worst of times,\n")
.append("it was the age of wisdom, it was the age of foolishness,\n")
.append("it was the epoch of belief, it was the epoch of incredulity,\n")
.append("it was the season of Light, it was the season of Darkness,\n")
.append("it was the spring of hope, it was the winter of despair,\n")
.append("we had everything before us, we had nothing before us")
.toString();
与String.format()：
String s = String.format("%s\n%s\n%s\n%s\n%s\n%s"
, "It was the best of times, it was the worst of times,"
, "it was the age of wisdom, it was the age of foolishness,"
, "it was the epoch of belief, it was the epoch of incredulity,"
, "it was the season of Light, it was the season of Darkness,"
, "it was the spring of hope, it was the winter of despair,"
, "we had everything before us, we had nothing before us"
);
与Java8 String.join()对比：
String s = String.join("\n"
, "It was the best of times, it was the worst of times,"
, "it was the age of wisdom, it was the age of foolishness,"
, "it was the epoch of belief, it was the epoch of incredulity,"
, "it was the season of Light, it was the season of Darkness,"
, "it was the spring of hope, it was the winter of despair,"
, "we had everything before us, we had nothing before us"
);
如果你想要特定系统的换行符，你需要使用System.getProperty("line.separator")，或者你可以在%n中使用String.format。
另一种选择是将资源放在文本文件中，只读取该文件的内容。这对于非常大的字符串来说是首选，以避免不必要地膨胀您的类文件。
import org.apache.commons.lang3.StringUtils;
String multiline = StringUtils.join(new String[] {
"It was the best of times, it was the worst of times ",
"it was the age of wisdom, it was the age of foolishness",
"it was the epoch of belief, it was the epoch of incredulity",
"it was the season of Light, it was the season of Darkness",
"it was the spring of hope, it was the winter of despair",
"we had everything before us, we had nothing before us",
}, "\n");
如果你像我一样喜欢谷歌的番石榴，它可以提供一个相当干净的表示和一个很好的，简单的方法来不硬编码您的换行符：
String out = Joiner.on(newline).join(ImmutableList.of(
"line1",
"line2",
"line3"));
使用Properties.loadFromXML(InputStream)。不需要外部库。
比杂乱的代码更好（因为可维护性和设计是你的问题），最好不要使用长字符串。 首先阅读xml属性：
InputStream fileIS = YourClass.class.getResourceAsStream("MultiLine.xml");
Properties prop = new Properies();
prop.loadFromXML(fileIS);
那么你可以以更易维护的方式使用你的多线字符串......
static final String UNIQUE_MEANINGFUL_KEY = "Super Duper UNIQUE Key";
prop.getProperty(UNIQUE_MEANINGFUL_KEY) // "\n MEGA\n LONG\n..."
MultiLine.xml`位于同一文件夹YourClass中：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
<entry key="Super Duper UNIQUE Key">
MEGA
LONG
MULTILINE
</entry>
</properties>
PS。：您可以使用<![CDATA[" ... "]]>用于类似xml的字符串。
一个非常有效且独立于平台的解决方案是使用行分隔符的系统属性和StringBuilder类来构建字符串：
String separator = System.getProperty("line.separator");
String[] lines = {"Line 1", "Line 2" /*, ... */};
StringBuilder builder = new StringBuilder(lines[0]);
for (int i = 1; i < lines.length(); i++) {
builder.append(separator).append(lines[i]);
}
String multiLine = builder.toString();
使用JDK/12 early access build # 12，现在可以在Java中使用多行字符串，如下所示：
String multiLine = `First line
Second line with indentation
Third line
and so on...`; // the formatting as desired
System.out.println(multiLine);
这导致以下输出：
First line Second line with indentation Third line and so on...
在属性文件中定义我的字符串？
属性文件中不允许使用多行字符串。您可以在属性文件中使用\ n，但我认为这不是您的大多数解决方案。
一个不错的选择。
import static some.Util.*;
public class Java {
public static void main(String[] args) {
String sql = $(
"Select * from java",
"join some on ",
"group by"
);
System.out.println(sql);
}
}
public class Util {
public static String $(String ...sql){
return String.join(System.getProperty("line.separator"),sql);
}
}
我知道这是一个老问题，但对于感兴趣的开发人员来说，Multiline文字将会出现在＃Java12中
http://mail.openjdk.java.net/pipermail/amber-dev/2018-July/003254.html
我建议使用ThomasP建议的实用程序，然后将其链接到您的构建过程中。仍然存在外部文件以包含文本，但在运行时不读取该文件。然后工作流程为：
class TextBlock {...的标头，后跟一个静态字符串，该字符串是从资源文件自动生成的当使用一长串+时，只创建一个StringBuilder，除非在编译时确定String，在这种情况下不使用StringBuilder！
StringBuilder唯一有效的时候是使用多个语句来构造String。
String a = "a\n";
String b = "b\n";
String c = "c\n";
String d = "d\n";
String abcd = a + b + c + d;
System.out.println(abcd);
String abcd2 = "a\n" +
"b\n" +
"c\n" +
"d\n";
System.out.println(abcd2);
注意：只创建一个StringBuilder。
Code:
0: ldc #2; //String a\n
2: astore_1
3: ldc #3; //String b\n
5: astore_2
6: ldc #4; //String c\n
8: astore_3
9: ldc #5; //String d\n
11: astore 4
13: new #6; //class java/lang/StringBuilder
16: dup
17: invokespecial #7; //Method java/lang/StringBuilder."<init>":()V
20: aload_1
21: invokevirtual #8; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
24: aload_2
25: invokevirtual #8; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
28: aload_3
29: invokevirtual #8; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
32: aload 4
34: invokevirtual #8; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
37: invokevirtual #9; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;
40: astore 5
42: getstatic #10; //Field java/lang/System.out:Ljava/io/PrintStream;
45: aload 5
47: invokevirtual #11; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
50: ldc #12; //String a\nb\nc\nd\n
52: astore 6
54: getstatic #10; //Field java/lang/System.out:Ljava/io/PrintStream;
57: aload 6
59: invokevirtual #11; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
62: return
为了进一步澄清我的问题，我根本不关心表现。我担心可维护性和设计问题。
尽可能简洁明了。
在Eclipse中，如果打开选项“粘贴到字符串文字时转义文本”（在“首选项”>“Java”>“编辑器”>“键入”中）并在引号中粘贴多行字符串，它将自动为所有行添加"和\n" +。
String str = "paste your text here";
一个小技巧。使用这个我在动态创建的HTML页面中注入javascript
StringBuilder builder = new StringBuilder();
public String getString()
{
return builder.toString();
}
private DropdownContent _(String a)
{
builder.append(a);
return this;
}
public String funct_showhide()
{
return
_("function slidedown_showHide(boxId)").
_("{").
_("if(!slidedown_direction[boxId])slidedown_direction[boxId] = 1;").
_("if(!slideDownInitHeight[boxId])slideDownInitHeight[boxId] = 0;").
_("if(slideDownInitHeight[boxId]==0)slidedown_direction[boxId]=slidedownSpeed; ").
_("else slidedown_direction[boxId] = slidedownSpeed*-1;").
_("slidedownContentBox = document.getElementById(boxId);").
_("var subDivs = slidedownContentBox.getElementsByTagName('DIV');").
_("for(var no=0;no<subDivs.length;no++){").
_(" if(subDivs[no].className=='dhtmlgoodies_content')slidedownContent = subDivs[no];").
_("}").
_("contentHeight = slidedownContent.offsetHeight;").
_("slidedownContentBox.style.visibility='visible';").
_("slidedownActive = true;").
_("slidedown_showHide_start(slidedownContentBox,slidedownContent);").
_("}").getString();
}
这是一个旧的线程，但是一个新的非常优雅的解决方案（只有4个可能有3个小缺点）是使用自定义注释。
检查：http://www.adrianwalker.org/2011/12/java-multiline-string.html
受这项工作启发的项目在GitHub上托管：
https://github.com/benelog/multiline
Java代码示例：
import org.adrianwalker.multilinestring.Multiline;
...
public final class MultilineStringUsage {
/**
<html>
<head/>
<body>
<p>
Hello<br/>
Multiline<br/>
World<br/>
</p>
</body>
</html>
*/
@Multiline
private static String html;
public static void main(final String[] args) {
System.out.println(html);
}
}
缺点是
<%= variable %>）:-)您可能必须将Eclipse / Intellij-Idea配置为不自动重新格式化您的Javadoc注释。
有人可能会发现这很奇怪（Javadoc的注释并不是为了嵌入除注释之外的其他内容），但由于Java中缺少多行字符串最终会让人烦恼，我发现这是最差的解决方案。
另一个选项可能是将长字符串存储在外部文件中并将该文件读入字符串。
这是你不应该在不考虑它正在做什么的情况下使用的东西。但是对于一次性脚本我已经使用了这个非常成功：
例：
System.out.println(S(/*
This is a CRAZY " ' ' " multiline string with all sorts of strange
characters!
*/));
码：
// From: http://blog.efftinge.de/2008/10/multi-line-string-literals-in-java.html
// Takes a comment (/**/) and turns everything inside the comment to a string that is returned from S()
public static String S() {
StackTraceElement element = new RuntimeException().getStackTrace()[1];
String name = element.getClassName().replace('.', '/') + ".java";
StringBuilder sb = new StringBuilder();
String line = null;
InputStream in = classLoader.getResourceAsStream(name);
String s = convertStreamToString(in, element.getLineNumber());
return s.substring(s.indexOf("/*")+2, s.indexOf("*/"));
}
// From http://www.kodejava.org/examples/266.html
private static String convertStreamToString(InputStream is, int lineNum) {
/*
* To convert the InputStream to String we use the BufferedReader.readLine()
* method. We iterate until the BufferedReader return null which means
* there's no more data to read. Each line will appended to a StringBuilder
* and returned as String.
*/
BufferedReader reader = new BufferedReader(new InputStreamReader(is));
StringBuilder sb = new StringBuilder();
String line = null; int i = 1;
try {
while ((line = reader.readLine()) != null) {
if (i++ >= lineNum) {
sb.append(line + "\n");
}
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return sb.toString();
}
String.joinJava 8为java.lang.String添加了一个新的静态方法，它提供了一个更好的选择：
String.join(
CharSequence delimiter ,
CharSequence... elements
)
使用它：
String s = String.join(
System.getProperty("line.separator"),
"First line.",
"Second line.",
"The rest.",
"And the last!"
);
如果在属性文件中定义字符串，它看起来会更糟糕。 IIRC，它看起来像：
string:text\u000atext\u000atext\u000a
通常，不将大字符串嵌入到源代码中是一个合理的想法。您可能希望将它们作为资源加载，可能是XML或可读文本格式。文本文件可以在运行时读取，也可以编译为Java源代码。如果您最终将它们放置在源中，我建议将+放在前面并省略不必要的新行：
final String text = ""
+"text "
+"text "
+"text"
;
如果您有新行，您可能需要一些连接或格式化方法：
final String text = join("\r\n"
,"text"
,"text"
,"text"
);
将两个字符串转换为StringBuilder.append，除非两个字符串都是常量，因此编译器可以在编译时将它们组合在一起。至少，这就是Sun编译器中的情况，如果不是所有其他编译器都会这样做，我会怀疑大多数编译器。
所以：
String a="Hello";
String b="Goodbye";
String c=a+b;
通常生成完全相同的代码：
String a="Hello";
String b="Goodbye":
StringBuilder temp=new StringBuilder();
temp.append(a).append(b);
String c=temp.toString();
另一方面：
String c="Hello"+"Goodbye";
是相同的：
String c="HelloGoodbye";
也就是说，在多行中打破你的字符串文字没有任何惩罚，加号为可读性。