Ich komme aus Perl und vermisse sicher die "Here-Document" -Methode zum Erstellen einer mehrzeiligen Zeichenfolge im Quellcode:

$string = <<"EOF"  # create a three-line string
text
text
text
EOF

In Java muss ich umständliche Anführungszeichen und Pluszeichen in jeder Zeile haben, wenn ich meine mehrzeilige Zeichenfolge von Grund auf verkette.

Was sind bessere Alternativen? Meine Zeichenfolge in einer Eigenschaftendatei definieren?

Bearbeiten : Zwei Antworten besagen, dass StringBuilder.append () der Plus-Notation vorzuziehen ist. Könnte jemand erläutern, warum er so denkt? Es sieht für mich überhaupt nicht besser aus. Ich suche nach einem Weg, um die Tatsache zu umgehen, dass mehrzeilige Zeichenfolgen kein erstklassiges Sprachkonstrukt sind, was bedeutet, dass ich ein erstklassiges Sprachkonstrukt (Zeichenfolgenverkettung mit Plus) definitiv nicht durch Methodenaufrufe ersetzen möchte.

Bearbeiten : Um meine Frage weiter zu klären, mache ich mir überhaupt keine Sorgen um die Leistung. Ich mache mir Sorgen um Wartbarkeit und Designprobleme.

Stephen Colebourne hat einen Vorschlag zum Hinzufügen mehrzeiliger Zeichenfolgen in Java 7 erstellt.

Außerdem unterstützt Groovy bereits mehrzeilige Zeichenfolgen .

Es hört sich so an, als ob Sie ein mehrzeiliges Literal erstellen möchten, das in Java nicht vorhanden ist.

Ihre beste Alternative werden Saiten sein, die nur +zusammen passen. Einige andere Optionen, die bereits erwähnt wurden (StringBuilder, String.format, String.join), sind nur vorzuziehen, wenn Sie mit einem Array von Zeichenfolgen begonnen haben.

Bedenken Sie:

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";

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

Versus 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"
);

Versus 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"
);

Wenn Sie das Newline für Ihr spezielles System wollen, müssen Sie entweder die Verwendung System.lineSeparator()oder Sie verwenden können , %nin String.format.

Eine andere Möglichkeit besteht darin, die Ressource in eine Textdatei einzufügen und nur den Inhalt dieser Datei zu lesen. Dies ist für sehr große Zeichenfolgen vorzuziehen, um ein unnötiges Aufblähen Ihrer Klassendateien zu vermeiden.

Wenn Sie in Eclipse die Option "Escape-Text beim Einfügen in ein Zeichenfolgenliteral" aktivieren (unter Einstellungen> Java> Editor> Eingabe) und eine mehrzeilige Zeichenfolge in Anführungszeichen einfügen, wird automatisch "und \n" +für alle Ihre Zeilen hinzugefügt .

String str = "paste your text here";

Dies ist ein alter Thread, aber eine neue, recht elegante Lösung (mit nur 4 oder 3 kleinen Nachteilen) besteht darin, eine benutzerdefinierte Anmerkung zu verwenden.

Überprüfen Sie: http://www.adrianwalker.org/2011/12/java-multiline-string.html

Ein von dieser Arbeit inspiriertes Projekt wird auf GitHub gehostet:

https://github.com/benelog/multiline

Beispiel für Java-Code:

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

Die Nachteile sind

1. dass Sie den entsprechenden (mitgelieferten) Anmerkungsprozessor aktivieren müssen.
2. Diese String-Variable kann nicht als lokale Variable definiert werden. Überprüfen Sie das Raw Raw String Literals-Projekt, in dem Sie Variablen als lokale Variablen definieren können
3. Dieser String kann keine anderen Variablen wie in Visual Basic .Net mit XML-Literal ( <%= variable %>) enthalten :-)
4. Dieses String-Literal wird durch einen JavaDoc-Kommentar (/ **) begrenzt.

Und Sie müssen wahrscheinlich Eclipse / Intellij-Idea so konfigurieren, dass Ihre Javadoc-Kommentare nicht automatisch neu formatiert werden.

Man mag dies seltsam finden (Javadoc-Kommentare sind nicht dazu gedacht, etwas anderes als Kommentare einzubetten), aber da dieser Mangel an mehrzeiligen Zeichenfolgen in Java am Ende wirklich ärgerlich ist, finde ich dies die am wenigsten schlimmste Lösung.

Eine andere Möglichkeit kann darin bestehen, lange Zeichenfolgen in einer externen Datei zu speichern und die Datei in eine Zeichenfolge einzulesen.

Dies ist etwas, das Sie niemals verwenden sollten , ohne darüber nachzudenken, was es tut. Aber für einmalige Skripte habe ich dies mit großem Erfolg verwendet:

Beispiel:

    System.out.println(S(/*
This is a CRAZY " ' ' " multiline string with all sorts of strange 
   characters!
*/));

Code:

// 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 hat eine neue statische Methode hinzugefügt, java.lang.Stringdie eine etwas bessere Alternative bietet:

String.join( CharSequence delimiter , CharSequence... elements )

Es benutzen:

String s = String.join(
    System.getProperty("line.separator"),
    "First line.",
    "Second line.",
    "The rest.",
    "And the last!"
);

JEP 355: Textblöcke (Vorschau) soll diese Funktionalität abdecken. Derzeit wird JDK 13 als Vorschaufunktion verwendet. Erlauben, etwas zu schreiben wie:

String s = """
    text
    text
    text
  """;

Vor diesem JEP in JDK12 zielte JEP 326: Raw String Literals darauf ab, eine ähnliche Funktion zu implementieren, die jedoch endgültig zurückgezogen wurde.

Wenn Sie Ihre Zeichenfolgen in einer Eigenschaftendatei definieren, sieht es viel schlechter aus. IIRC, es wird aussehen wie:

string:text\u000atext\u000atext\u000a

Im Allgemeinen ist es eine vernünftige Idee, keine großen Zeichenfolgen in die Quelle einzubetten. Möglicherweise möchten Sie sie als Ressourcen laden, möglicherweise in XML oder einem lesbaren Textformat. Die Textdateien können entweder zur Laufzeit gelesen oder in eine Java-Quelle kompiliert werden. Wenn Sie sie am Ende in der Quelle platzieren, empfehle ich, die +an die Vorderseite zu setzen und unnötige neue Zeilen wegzulassen:

final String text = ""
    +"text "
    +"text "
    +"text"
;

Wenn Sie neue Zeilen haben, möchten Sie möglicherweise einige Verknüpfungs- oder Formatierungsmethoden:

final String text = join("\r\n"
    ,"text"
    ,"text"
    ,"text"
);

Pluspunkte werden in StringBuilder.append konvertiert, außer wenn beide Zeichenfolgen Konstanten sind, damit der Compiler sie zur Kompilierungszeit kombinieren kann. Zumindest ist das in Suns Compiler so, und ich würde die meisten vermuten, wenn nicht alle anderen Compiler dasselbe tun würden.

Damit:

String a="Hello";
String b="Goodbye";
String c=a+b;

generiert normalerweise genau den gleichen Code wie:

String a="Hello";
String b="Goodbye":
StringBuilder temp=new StringBuilder();
temp.append(a).append(b);
String c=temp.toString();

Auf der anderen Seite:

String c="Hello"+"Goodbye";

ist das gleiche wie:

String c="HelloGoodbye";

Das heißt, es gibt keine Strafe, wenn Sie Ihre String-Literale über mehrere Zeilen mit Pluszeichen für die Lesbarkeit aufteilen.

In der IntelliJ IDE müssen Sie nur Folgendes eingeben:

""

Positionieren Sie dann den Cursor innerhalb der Anführungszeichen und fügen Sie die Zeichenfolge ein. Die IDE erweitert es in mehrere verkettete Zeilen.

Leider verfügt Java nicht über mehrzeilige Zeichenfolgenliterale. Sie müssen entweder Zeichenfolgenliterale verketten (wobei + oder StringBuilder die beiden am häufigsten verwendeten Ansätze sind) oder die Zeichenfolge aus einer separaten Datei einlesen.

Bei großen mehrzeiligen Zeichenfolgenliteralen würde ich gerne eine separate Datei verwenden und diese mit getResourceAsStream()(einer Methode der ClassKlasse) einlesen . Dies erleichtert das Auffinden der Datei, da Sie sich keine Gedanken über das aktuelle Verzeichnis und den Installationsort Ihres Codes machen müssen. Dies erleichtert auch das Verpacken, da Sie die Datei tatsächlich in Ihrer JAR-Datei speichern können.

Angenommen, Sie sind in einer Klasse namens Foo. Mach einfach so etwas:

Reader r = new InputStreamReader(Foo.class.getResourceAsStream("filename"), "UTF-8");
String s = Utils.readAll(r);

Das einzige andere Ärgernis ist, dass Java nicht über die Standardmethode "Lesen Sie den gesamten Text dieses Readers in einen String" verfügt. Es ist allerdings ziemlich einfach zu schreiben:

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

Die beste Alternative ist jedoch die Verwendung von String.format

String multilineString = String.format("%s\n%s\n%s\n",line1,line2,line3);

Da Java (noch) nicht native mehrzeilige Zeichenfolgen unterstützt, besteht die einzige Möglichkeit im Moment darin, sie mit einer der oben genannten Techniken zu umgehen. Ich habe das folgende Python-Skript mit einigen der oben genannten Tricks erstellt:

import sys
import string
import os

print 'new String('
for line in sys.stdin:
    one = string.replace(line, '"', '\\"').rstrip(os.linesep)
    print '  + "' + one + ' "'
print ')'

Fügen Sie dies in eine Datei mit dem Namen javastringify.py und Ihre Zeichenfolge in eine Datei mystring.txt ein und führen Sie sie wie folgt aus:

cat mystring.txt | python javastringify.py

Sie können die Ausgabe dann kopieren und in Ihren Editor einfügen.

Ändern Sie dies nach Bedarf, um Sonderfälle zu behandeln, aber dies funktioniert für meine Anforderungen. Hoffe das hilft!

Sie können Scala-Code verwenden, der mit Java kompatibel ist und mehrzeilige Zeichenfolgen zulässt, die mit "" "eingeschlossen sind:

package foobar
object SWrap {
  def bar = """John said: "This is
  a test
  a bloody test,
  my dear." and closed the door.""" 
}

(Beachten Sie die Anführungszeichen in der Zeichenfolge) und aus Java:

String s2 = foobar.SWrap.bar ();

Ob das bequemer ist ...?

Ein anderer Ansatz, wenn Sie häufig langen Text verarbeiten, der in Ihren Quellcode eingefügt werden sollte, könnte ein Skript sein, das den Text aus einer externen Datei entnimmt und wie folgt in einen mehrzeiligen Java-String umschließt:

sed '1s/^/String s = \"/;2,$s/^/\t+ "/;2,$s/$/"/' file > file.java

damit Sie es einfach ausschneiden und in Ihre Quelle einfügen können.

Sie können Ihre Anhänge in einer separaten Methode verketten:

public static String multilineString(String... lines){
   StringBuilder sb = new StringBuilder();
   for(String s : lines){
     sb.append(s);
     sb.append ('\n');
   }
   return sb.toString();
}

In beiden Fällen bevorzugen Sie StringBuilderdie Plus-Notation.

Das Folgende ist die sauberste Implementierung, die ich bisher gesehen habe. Es verwendet eine Anmerkung, um einen Kommentar in eine Zeichenfolgenvariable umzuwandeln ...

/**
  <html>
    <head/>
    <body>
      <p>
        Hello<br/>
        Multiline<br/>
        World<br/>
      </p>
    </body>
  </html>
  */
  @Multiline
  private static String html;

Das Endergebnis ist also, dass die Variable HTML die mehrzeilige Zeichenfolge enthält. Keine Anführungszeichen, keine Pluszeichen, keine Kommas, nur reine Zeichenfolge.

Diese Lösung ist unter der folgenden URL verfügbar ... http://www.adrianwalker.org/2011/12/java-multiline-string.html

Ich hoffe, das hilft!

Siehe Java Stringfier . Verwandelt Ihren Text in einen StringBuilder-Java-Block, der bei Bedarf ausgeblendet wird.

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

Eine Alternative, die ich noch nicht als Antwort gesehen habe, ist die 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();

Auch die Tatsache, dass java.io.BufferedWriteres eine newLine()Methode gibt, wird nicht erwähnt.

Wenn Sie Googles Guave genauso mögen wie ich, kann dies eine ziemlich saubere Darstellung und eine schöne, einfache Möglichkeit bieten, auch Ihre Zeilenumbruchzeichen nicht fest zu codieren:

String out = Joiner.on(newline).join(ImmutableList.of(
    "line1",
    "line2",
    "line3"));

Verwenden Sie Properties.loadFromXML(InputStream). Es sind keine externen Bibliotheken erforderlich.

Besser als ein unordentlicher Code (da Wartbarkeit und Design Ihr Anliegen sind), ist es vorzuziehen, keine langen Zeichenfolgen zu verwenden.

Beginnen Sie mit dem Lesen der XML-Eigenschaften:

 InputStream fileIS = YourClass.class.getResourceAsStream("MultiLine.xml");
 Properties prop = new Properies();
 prop.loadFromXML(fileIS);

Dann können Sie Ihre mehrzeilige Zeichenfolge auf eine wartbarere Weise verwenden ...

static final String UNIQUE_MEANINGFUL_KEY = "Super Duper UNIQUE Key";
prop.getProperty(UNIQUE_MEANINGFUL_KEY) // "\n    MEGA\n   LONG\n..."

MultiLine.xml` befindet sich im selben Ordner 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.: Sie können <![CDATA["... "]]>für XML-ähnliche Zeichenfolgen verwenden.

Mit JDK / 12 Early Access Build Nr. 12 können jetzt mehrzeilige Zeichenfolgen in Java wie folgt verwendet werden:

String multiLine = `First line
    Second line with indentation
Third line
and so on...`; // the formatting as desired
System.out.println(multiLine);

und dies führt zu folgender Ausgabe:

First line
    Second line with indentation
Third line
and so on...

Bearbeiten: Auf Java 13 verschoben

Eine recht effiziente und plattformunabhängige Lösung wäre die Verwendung der Systemeigenschaft für Zeilentrennzeichen und der StringBuilder-Klasse zum Erstellen von Zeichenfolgen:

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

Eine gute Option.

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

    }

Dies ist eine sehr häufige Frage, daher habe ich beschlossen, diese Antwort auch in einen Artikel umzuwandeln .

Java 13 und darüber hinaus

Mehrzeilige Zeichenfolgen werden jetzt in Java über Textblöcke unterstützt . In Java 13 und 14 müssen Sie für diese Funktion die Einstellungen vornehmen––enable–preview Option wenn Sie Ihr Projekt erstellen und ausführen. Weitere Informationen finden Sie in dieser Java-Dokumentation .

Vor Java 13 schreiben Sie eine Abfrage folgendermaßen:

List<Tuple> posts = entityManager
.createNativeQuery(
    "SELECT *\n" +
    "FROM (\n" +
    "    SELECT *,\n" +
    "           dense_rank() OVER (\n" +
    "               ORDER BY \"p.created_on\", \"p.id\"\n" +
    "           ) rank\n" +
    "    FROM (\n" +
    "        SELECT p.id AS \"p.id\",\n" +
    "               p.created_on AS \"p.created_on\",\n" +
    "               p.title AS \"p.title\",\n" +
    "               pc.id as \"pc.id\",\n" +
    "               pc.created_on AS \"pc.created_on\",\n" +
    "               pc.review AS \"pc.review\",\n" +
    "               pc.post_id AS \"pc.post_id\"\n" +
    "        FROM post p\n" +
    "        LEFT JOIN post_comment pc ON p.id = pc.post_id\n" +
    "        WHERE p.title LIKE :titlePattern\n" +
    "        ORDER BY p.created_on\n" +
    "    ) p_pc\n" +
    ") p_pc_r\n" +
    "WHERE p_pc_r.rank <= :rank\n",
    Tuple.class)
.setParameter("titlePattern", "High-Performance Java Persistence %")
.setParameter("rank", 5)
.getResultList();

Dank Java 13-Textblöcken können Sie diese Abfrage wie folgt umschreiben:

List<Tuple> posts = entityManager
.createNativeQuery("""
    SELECT *
    FROM (
        SELECT *,
               dense_rank() OVER (
                   ORDER BY "p.created_on", "p.id"
               ) rank
        FROM (
            SELECT p.id AS "p.id",
                   p.created_on AS "p.created_on",
                   p.title AS "p.title",
                   pc.id as "pc.id",
                   pc.created_on AS "pc.created_on",
                   pc.review AS "pc.review",
                   pc.post_id AS "pc.post_id"
            FROM post p
            LEFT JOIN post_comment pc ON p.id = pc.post_id
            WHERE p.title LIKE :titlePattern
            ORDER BY p.created_on
        ) p_pc
    ) p_pc_r
    WHERE p_pc_r.rank <= :rank
    """,
    Tuple.class)
.setParameter("titlePattern", "High-Performance Java Persistence %")
.setParameter("rank", 5)
.getResultList();

Viel lesbarer, oder?

IDE-Unterstützung

IntelliJ IDEA bietet Unterstützung für die Umwandlung älterer StringVerkettungsblöcke in das neue mehrzeilige StringFormat:

JSON, HTML, XML

Die mehrzeilige String ist besonders nützlich, wenn Sie JSON, HTML oder XML schreiben.

Betrachten Sie dieses Beispiel mithilfe der StringVerkettung, um ein JSON-Zeichenfolgenliteral zu erstellen:

entityManager.persist(
    new Book()
    .setId(1L)
    .setIsbn("978-9730228236")
    .setProperties(
        "{" +
        "   \"title\": \"High-Performance Java Persistence\"," +
        "   \"author\": \"Vlad Mihalcea\"," +
        "   \"publisher\": \"Amazon\"," +
        "   \"price\": 44.99," +
        "   \"reviews\": [" +
        "       {" +
        "           \"reviewer\": \"Cristiano\", " +
        "           \"review\": \"Excellent book to understand Java Persistence\", " +
        "           \"date\": \"2017-11-14\", " +
        "           \"rating\": 5" +
        "       }," +
        "       {" +
        "           \"reviewer\": \"T.W\", " +
        "           \"review\": \"The best JPA ORM book out there\", " +
        "           \"date\": \"2019-01-27\", " +
        "           \"rating\": 5" +
        "       }," +
        "       {" +
        "           \"reviewer\": \"Shaikh\", " +
        "           \"review\": \"The most informative book\", " +
        "           \"date\": \"2016-12-24\", " +
        "           \"rating\": 4" +
        "       }" +
        "   ]" +
        "}"
    )
);

Sie können den JSON aufgrund der entweichenden Zeichen und der Fülle an doppelten Anführungszeichen und Pluszeichen kaum lesen.

Mit Java-Textblöcken kann das JSON-Objekt folgendermaßen geschrieben werden:

entityManager.persist(
    new Book()
    .setId(1L)
    .setIsbn("978-9730228236")
    .setProperties("""
        {
           "title": "High-Performance Java Persistence",
           "author": "Vlad Mihalcea",
           "publisher": "Amazon",
           "price": 44.99,
           "reviews": [
               {
                   "reviewer": "Cristiano",
                   "review": "Excellent book to understand Java Persistence",
                   "date": "2017-11-14",
                   "rating": 5
               },
               {
                   "reviewer": "T.W",
                   "review": "The best JPA ORM book out there",
                   "date": "2019-01-27",
                   "rating": 5
               },
               {
                   "reviewer": "Shaikh",
                   "review": "The most informative book",
                   "date": "2016-12-24",
                   "rating": 4
               }
           ]
        }
        """
    )
);

Seit ich 2004 C # verwendet habe, wollte ich diese Funktion in Java haben, und jetzt haben wir sie endlich.

Meine Zeichenfolge in einer Eigenschaftendatei definieren?

Mehrzeilige Zeichenfolgen sind in Eigenschaftendateien nicht zulässig. Sie können \ n in Eigenschaftendateien verwenden, aber ich denke nicht, dass dies in Ihrem Fall eine gute Lösung ist.

Ich weiß, dass dies eine alte Frage ist, aber für interessierte Entwickler werden mehrzeilige Literale in # Java12 sein

http://mail.openjdk.java.net/pipermail/amber-dev/2018-July/003254.html

Ich schlage vor, ein von ThomasP vorgeschlagenes Dienstprogramm zu verwenden und dieses dann mit Ihrem Erstellungsprozess zu verknüpfen. Es ist noch eine externe Datei vorhanden, die den Text enthält, aber die Datei wird zur Laufzeit nicht gelesen. Der Workflow lautet dann:

1. Erstellen Sie ein Dienstprogramm "Textdatei in Java-Code" und checken Sie in die Versionskontrolle ein
2. Führen Sie das Dienstprogramm bei jedem Build für die Ressourcendatei aus, um eine überarbeitete Java-Quelle zu erstellen
3. Die Java-Quelle enthält einen Header wie class TextBlock {... gefolgt von einer statischen Zeichenfolge, die automatisch aus der Ressourcendatei generiert wird
4. Erstellen Sie die generierte Java-Datei mit dem Rest Ihres Codes

Wenn eine lange Reihe von + verwendet wird, wird nur ein StringBuilder erstellt, es sei denn, der String wird zur Kompilierungszeit festgelegt. In diesem Fall wird kein StringBuilder verwendet!

StringBuilder ist nur dann effizienter, wenn mehrere Anweisungen zum Erstellen des Strings verwendet werden.

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

Hinweis: Es wird nur ein StringBuilder erstellt.

  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

Um meine Frage weiter zu klären, mache ich mir überhaupt keine Sorgen um die Leistung. Ich mache mir Sorgen um Wartbarkeit und Designprobleme.

Machen Sie es so klar und einfach wie möglich.