Javaマルチライン文字列
Perlから来た、私は確かにソースコードで複数行の文字列を作成するための "ヒアドキュメント"の手段が欠けています：
$string = <<"EOF" # create a three-line string
text
text
text
EOF
Javaでは、複数行の文字列を最初から連結するため、各行に面倒な引用符とプラス記号を付ける必要があります。
いくつかのより良い代替手段は何ですか？プロパティファイルに文字列を定義しますか？
編集 ：2つの答えは、StringBuilder.append（）がプラス記法より望ましいと言います。誰がそのように考えるのかについて詳しく述べることができますか？私にとってはそれほど好ましくはありません。私は、複数行の文字列が第一級の言語構成要素ではないという事実を回避する方法を探しています。つまり、第一級言語の構成要素（プラスと文字列の連結）をメソッド呼び出しに置き換えたくないということです。
編集 ：私の質問をさらに明確にするために、パフォーマンスについてはまったく心配していません。保守性とデザインの問題が心配です。
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を使うことができます。
他の選択肢は、リソースをテキストファイルに入れ、そのファイルの内容を読むことです。クラスファイルが不必要に肥大化するのを避けるために、これは非常に大きな文字列にとっては望ましいでしょう。
Eclipseで（[設定]> [Java]> [エディタ]> [入力]で）[文字列リテラルに貼り付けるときにテキストをエスケープする]オプションをオンにし、引用符で囲まれた複数行の文字列を貼り付けると、すべての行に"と\n" +が自動的に追加されます。
String str = "paste your text here";
これは古いスレッドですが、カスタムアノテーションを使用することで、新しいエレガントな解決策（わずか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);
}
}
欠点は
- 対応する（提供されている）注釈プロセッサをアクティブにする必要があります。
- その文字列変数をローカル変数として定義することはできませんチェック 生の文字列リテラルプロジェクト ローカル変数として変数を定義できる場所
- その文字列は、XMLリテラル（
<%= variable %>）を持つVisual Basic .NETのように他の変数を含むことはできません:-) - stringリテラルはJavaDocコメント（/ **）で区切られている
そしておそらくあなたはJavadocのコメントを自動的に再フォーマットしないようにEclipse/Intellij-Ideaを設定しなければならないでしょう。
Javadocのコメントはコメント以外のものを埋め込むようには設計されていませんが、Javaでは複数行の文字列がないことが最終的には非常に厄介なので、これが最悪の解決策であると思います。
もう1つの選択肢は、長い文字列を外部ファイルに格納し、そのファイルを文字列に読み込むことです。
これが何をしているのかを考えずに 決して を使うべきではないということです。しかし、1回限りのスクリプトでは、これを使用して大きな成功を収めました。
例：
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.join
Java 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";
つまり、読みやすくするためにプラス記号を付けて、文字列リテラルを複数行にまたがって分割してもペナルティはありません。
IntelliJ IDEでは、次のように入力するだけです。
""
次にカーソルを引用符の内側に置き、文字列を貼り付けます。 IDEはそれを複数の連結された行に展開します。
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には複数行の文字列リテラルがありません。文字列リテラルを連結する（これに最も一般的な2つの方法は+またはStringBuilderを使用する）か、別のファイルから文字列を読み込む必要があります。
大きな複数行の文字列リテラルの場合は、別のファイルを使用してgetResourceAsStream()（Classクラスのメソッド）を使用して読み込むことをお勧めします。現在のディレクトリとコードがインストールされている場所を気にする必要がないため、これによってファイルを簡単に見つけることができます。実際にファイルをjarファイルに格納できるため、パッケージ化も容易になります。
あなたがFooというクラスにいるとしましょう。このようなことをしてください。
Reader r = new InputStreamReader(Foo.class.getResourceAsStream("filename"), "UTF-8");
String s = Utils.readAll(r);
もう1つの厄介な点は、Javaには標準の「このReaderのテキストをすべてStringに読み込む」メソッドがないことです。しかし、書くのはとても簡単です。
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();
}
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 ();
これがもっと快適かどうか…？
もう1つの方法は、ソースコードに配置する必要がある長いテキストを扱う場合、外部ファイルからテキストを取り出して次のように複数行のJava文字列としてラップするスクリプトです。
sed '1s/^/String s = \"/;2,$s/^/\t+ "/;2,$s/$/"/' file > file.Java
あなたがそれをあなたのソースに簡単にカットアンドペーストできるように。
Javaは（まだ）ネイティブに複数行の文字列をサポートしていないので、今のところ唯一の方法は前述のテクニックの1つを使ってそれをハックすることです。上記のいくつかのトリックを使用して、次の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
その後、出力をコピーしてエディタに貼り付けることができます。
特別な場合を処理するために必要に応じてこれを修正してください、しかしこれは私の必要性のために働きます。お役に立てれば！
JEP 326：生の文字列リテラル は複数行の文字列を実装するので、次のように書くことができるでしょう。
String s = `
text
text
text
`;
次のような別の方法で追加を連結することができます。
public static String multilineString(String... lines){
StringBuilder sb = new StringBuilder();
for(String s : lines){
sb.append(s);
sb.append ('\n');
}
return sb.toString();
}
どちらの方法でも、プラス表記よりStringBuilderを優先してください。
Java Stringfier を参照してください。必要に応じてエスケープするStringBuilder Javaブロックにテキストを変換します。
実際には、以下は私が今まで見た中で最もクリーンな実装です。注釈を使用してコメントを文字列変数に変換します。
/**
<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.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()メソッドを持っているという事実も言及されていません。
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);
そして、あなたは より保守しやすい wayであなたの複数行の文字列を使うことができます...
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>
シモンズ：あなたはxmlのような文字列のために<![CDATA[" ... "]]>を使うことができます。
非常に効率的でプラットフォームに依存しない解決策は、文字列を構築するために行区切り文字と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();
プロパティファイルに文字列を定義しますか？
複数行の文字列はプロパティファイルでは使用できません。あなたはプロパティファイルで\ nを使うことができます、しかし私はあなたの場合それが解決策の大部分であるとは思わない。
私はThomasPによって提案されたようにユーティリティを使用することを提案し、そしてそれをあなたのビルドプロセスにリンクします。テキストを格納するための外部ファイルはまだ存在しますが、実行時にファイルは読み取られません。ワークフローは次のとおりです。
- 「textfile to Java code」ユーティリティを作成し、バージョン管理にチェックインする
- ビルドごとに、リソースファイルに対してユーティリティを実行して、修正されたJavaソースを作成します。
- Javaソースには、
class TextBlock {...のようなヘッダーとそれに続くリソースファイルから自動生成される静的文字列が含まれています。 - 残りのコードを使用して生成されたJavaファイルをビルドします。
一つの良い選択肢です。
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);
}
}
私はこれが古い質問であることを知っています、しかし興味を持っている開発者のために。
http://mail.openjdk.Java.net/pipermail/amber-dev/2018-July/003254.html
長い一連の+が使用されている場合、コンパイル時にStringが決定されない限りStringBuilderは1つだけ作成されます。この場合、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は1つだけ作成されます。
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
私の質問をさらに明確にするために、私はパフォーマンスについては全く心配していません。保守性とデザインの問題が心配です。
できるだけ明確でシンプルにしてください。
後期モデルのJavaは、定数文字列を使って+を最適化し、舞台裏でStringBufferを採用しているので、コードを乱雑にしたくないでしょう。
これはJavaの見落としを示しており、二重引用符で囲まれた文字列を空白で区切って自動的に連結することはANSI Cには似ていません。
const char usage = "\n"
"Usage: xxxx <options>\n"
"\n"
"Removes your options as designated by the required parameter <options>,\n"
"which must be one of the following strings:\n"
" love\n"
" sex\n"
" drugs\n"
" rockandroll\n"
"\n" ;
埋め込まれたラインフィードが尊重される場合は、複数行の文字配列定数を使用したいので、雑然としないようにブロックを表示できます。
String Query = "
SELECT
some_column,
another column
FROM
one_table a
JOIN
another_table b
ON a.id = b.id
AND a.role_code = b.role_code
WHERE a.dept = 'sales'
AND b.sales_quote > 1000
Order BY 1, 2
" ;
これを実現するには、Javaの神々に勝つ必要があります。
JDK/12アーリーアクセスビルド＃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...
1つの小さなトリックこれを使用して、動的に作成された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();
}
ちょっとクレイジーに思えるかもしれませんが、heredocsは改行をエスケープした一行宣言よりも構文上の糖であるため、前処理中にheredocsをシングルライナーに変更するプリプロセッサをJavaファイル用に書くことができます。
（ant/mavenビルドのための）コンパイル段階の前にファイルを前処理するための適切なプラグインとIDEへのプラグインを書く必要があるでしょう。
イデオロギーの観点からは、それはf.gと何も変わりません。 「ジェネリック」、それはまたキャスティング上の一種の前処理された構文糖です。
しかしながら、それは多くの作業を要するので、あなたの代わりに私はただ.propertiesファイルを使うでしょう。
私は時々ひもの袋のように振る舞うために平行グルーヴィーなクラスを使う
ここのJavaクラス
public class Test {
public static void main(String[] args) {
System.out.println(TestStrings.json1);
// consume .. parse json
}
}
そしてTestStrings.groovyでここで切望されている複数行の文字列
class TestStrings {
public static String json1 = """
{
"name": "Fakeer's Json",
"age":100,
"messages":["msg 1","msg 2","msg 3"]
}""";
}
もちろん、これは静的文字列専用です。テキストに変数を挿入する必要がある場合は、ファイル全体をgroovyに変更します。厳密な型付けの慣習を維持するだけで、それをやめることができます。
長い文字列に外部ファイルを使用することは避けなければならないケースが少なくとも1つあります。これらの長い文字列が単体テストファイルの期待値である場合外部リソースに頼る。
このライブラリを使う
https://github.com/alessio-santacroce/multiline-string-literals
このようなことを書くことは可能です
System.out.println(newString(/*
Wow, we finally have
multiline strings in
Java! HOOO!
*/));
とても素敵で簡単ですが、単体テストにしか使えません
私は、jdk7で複数行の構文が実際に計画されていることを読むのに少し苛立ちを感じました（何十年ものJavaの存在の後に）。おかしなことに、ファイルの内容全体を読み取るためのreadAll（）関数はまだありません（jdk7のみ、huhhから）ので、以下のコードは1行読み取ります。
/*
MakeMultiline v1.0（2010） - テキストのBLOBを1つのJava文字列リテラルに変換するための小さなガジェット
（行の分割を行い、両端に\ nを追加し、二重引用符で
を囲みます）。テキストblobで遭遇した引用符をエスケープしますか？
Java
以前のjdk7で欠落している複数行の文字列構文を回避するのに役立ちます。
Java MakeMultiline ""
または
Java MakeMultiline "" mytextfile.txt
*/
[.____ []。Javaのインポート.io。*;
クラスMakeMultiline {
public static void main（String [] args）{
try {
// args [0]：indent
// args [1]：読み込むファイル名（オプション。指定しない場合は標準入力）
//標準入力を使用するときは、最後の改行に注意してください。
文字列indent =（args.length> 0？args [0]： ""）;
FileReader fr = null; BufferedReader br;
if（args.length> 1）
{fr = new FileReader（args [1]）; br = new BufferedReader（fr）; else
{br = new BufferedReader（new InputStreamReader（System.in））;文字列s。文字列res = "";
while（（s = br.readLine（））！= null）{
if（res.length（）> 0）res + = "+\n" ;
res + = indent + "\" "+ s.replace（"\""、 "\\\" "）+" \\ n\"";
} [.____ br.close（）; if（fr！= null）fr.close（）;
System.out.println（res + ";"）;
}
catch（例外e）{[。 System.out.println（ "Exception：" + e）;
}
}
}
これは私にとって最も早い解決策でした。 （2010-01-27）
簡単な方法はSciTE（ http://www.scintilla.org/SciTEDownload.html ）のようなエディタであなたのJavaコードを編集することです。これは長い文字列が見やすくなるようにテキストをラップすることを可能にします。編集しました。エスケープ文字が必要な場合は、それらを入れるだけです。wrap-optionをオフにすることで、あなたの文字列が本当に長い単一行文字列であることを確認することができます。しかし、もちろん、そうでなければ、コンパイラーはあなたにも教えます。
EclipseとNetBeansのどちらがエディターでのテキストの折り返しをサポートしているかどうかは、私にはわかりません。それらには非常に多くのオプションがあるからです。そうでなければ、それは追加するのが良いでしょう。
私が知っている唯一の方法は、複数の行をプラス記号で連結することです