Proveniente da Perl, mi manca sicuramente il mezzo "here-document" per creare una stringa multilinea nel codice sorgente:

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

In Java, devo avere virgolette ingombranti e segni più su ogni riga mentre concateno la mia stringa multilinea da zero.

Quali sono alcune alternative migliori? Definire la mia stringa in un file delle proprietà?

Modifica : due risposte dicono che StringBuilder.append () è preferibile alla notazione più. Qualcuno potrebbe spiegare il motivo per cui la pensano così? Non mi sembra più preferibile. Sto cercando un modo per aggirare il fatto che le stringhe multilinea non sono un costrutto di linguaggio di prima classe, il che significa che sicuramente non voglio sostituire un costrutto di linguaggio di prima classe (concatenazione di stringhe con più) con chiamate di metodo.

Modifica : per chiarire ulteriormente la mia domanda, non sono affatto preoccupato per le prestazioni. Sono preoccupato per manutenibilità e problemi di progettazione.

Stephen Colebourne ha creato una proposta per l'aggiunta di stringhe multilinea in Java 7.

Inoltre, Groovy ha già il supporto per stringhe multilinea .

Sembra che tu voglia fare un letterale multilinea, che non esiste in Java.

La tua migliore alternativa saranno le stringhe che sono solo +insieme. Alcune altre opzioni citate dalla gente (StringBuilder, String.format, String.join) sarebbero preferibili solo se avessi iniziato con una matrice di stringhe.

Considera questo:

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

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

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

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

Se si desidera che la nuova riga per il sistema particolare, si sia bisogno di usare System.lineSeparator(), oppure è possibile utilizzare %nin String.format.

Un'altra opzione è quella di mettere la risorsa in un file di testo e leggere semplicemente il contenuto di quel file. Questo sarebbe preferibile per stringhe molto grandi per evitare di gonfiare inutilmente i file di classe.

In Eclipse se si attiva l'opzione "Esci dal testo quando si incolla in una stringa letterale" (in Preferenze> Java> Editor> Digitazione) e si incolla una stringa a più righe tra virgolette, si aggiungerà automaticamente "e \n" +per tutte le linee.

String str = "paste your text here";

Questo è un vecchio thread, ma una nuova soluzione abbastanza elegante (con solo 4 forse 3 piccoli inconvenienti) è quella di utilizzare un'annotazione personalizzata.

Controlla: http://www.adrianwalker.org/2011/12/java-multiline-string.html

Un progetto ispirato a quel lavoro è ospitato su GitHub:

https://github.com/benelog/multiline

Esempio di codice 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);
  }
}

Gli svantaggi sono

1. che devi attivare il corrispondente (fornito) processore di annotazione.
2. quella variabile String non può essere definita come variabile locale Controlla il progetto Raw String Literals dove puoi definire variabili come variabili locali
3. quella stringa non può contenere altre variabili come in .Net di Visual Basic con XML letterale ( <%= variable %>) :-)
4. quel valore letterale String è delimitato dal commento JavaDoc (/ **)

E probabilmente devi configurare Eclipse / Intellij-Idea per non riformattare automaticamente i tuoi commenti Javadoc.

Si potrebbe trovare questo strano (i commenti di Javadoc non sono progettati per incorporare nient'altro che commenti), ma poiché questa mancanza di stringa multilinea in Java alla fine è davvero fastidiosa, trovo che questa sia la soluzione meno peggiore.

Un'altra opzione potrebbe essere quella di archiviare stringhe lunghe in un file esterno e leggere il file in una stringa.

Questo è qualcosa che non dovresti mai usare senza pensare a cosa sta facendo. Ma per gli script una tantum l'ho usato con grande successo:

Esempio:

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

Codice:

// 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 ha aggiunto un nuovo metodo statico al java.lang.Stringquale offre un'alternativa leggermente migliore:

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

Usandolo:

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

JEP 355: Text Blocks (Anteprima) ha lo scopo di coprire questa funzionalità, attualmente è destinato a JDK 13 come funzionalità di anteprima. Permettere di scrivere qualcosa del tipo:

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

Precedentemente a questo JEP, in JDK12, JEP 326: Raw String Literals mirava a implementare una funzione simile, ma alla fine è stata ritirata.

Se definisci le tue stringhe in un file delle proprietà, sembrerà molto peggio. IIRC, assomiglierà a:

string:text\u000atext\u000atext\u000a

Generalmente è un'idea ragionevole non incorporare stringhe di grandi dimensioni nel sorgente. Potresti caricarli come risorse, magari in XML o in un formato di testo leggibile. I file di testo possono essere letti in fase di esecuzione o compilati in sorgente Java. Se finisci per metterli nella fonte, ti suggerisco di mettere il+ in primo piano e omettere nuove righe non necessarie:

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

Se hai nuove righe, potresti voler un po 'di metodo di join o formattazione:

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

I plus vengono convertiti in StringBuilder.append, tranne quando entrambe le stringhe sono costanti in modo che il compilatore possa combinarle al momento della compilazione. Almeno, è così che è nel compilatore di Sun, e sospetterei di più se non tutti gli altri compilatori farebbero lo stesso.

Così:

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

normalmente genera esattamente lo stesso codice di:

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

D'altro canto:

String c="Hello"+"Goodbye";

equivale a:

String c="HelloGoodbye";

Cioè, non vi è alcuna penalità nel rompere i letterali di stringa su più righe con segni più per la leggibilità.

Nell'IDE IntelliJ devi solo digitare:

""

Quindi posizionare il cursore tra virgolette e incollare la stringa. L'IDE lo espande in più righe concatenate.

Purtroppo, Java non ha valori letterali di stringa multilinea. Devi concatenare i valori letterali delle stringhe (usando + o StringBuilder sono i due approcci più comuni a questo) o leggere la stringa da un file separato.

Per i letterali con stringhe multilinea di grandi dimensioni sarei propenso a utilizzare un file separato e leggerlo usando getResourceAsStream()(un metodo diClass classe). Ciò semplifica la ricerca del file in quanto non è necessario preoccuparsi della directory corrente rispetto a dove è stato installato il codice. Inoltre semplifica il packaging, poiché è possibile archiviare effettivamente il file nel file jar.

Supponi di essere in una classe chiamata Foo. Fai qualcosa del genere:

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

L'altra seccatura è che Java non ha un metodo standard "leggi tutto il testo da questo Reader in una stringa". È abbastanza facile da scrivere però:

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

Ma la migliore alternativa è usare String.format

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

Poiché Java non supporta (ancora) nativamente le stringhe multilinea, l'unico modo per ora è di hackerarlo utilizzando una delle tecniche sopra menzionate. Ho creato il seguente script Python usando alcuni dei trucchi sopra menzionati:

import sys
import string
import os

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

Inseriscilo in un file chiamato javastringify.py e la tua stringa in un file mystring.txt ed eseguilo come segue:

cat mystring.txt | python javastringify.py

È quindi possibile copiare l'output e incollarlo nel proprio editor.

Modificalo come necessario per gestire eventuali casi speciali, ma funziona per le mie esigenze. Spero che sia di aiuto!

È possibile utilizzare lo scala-code, che è compatibile con Java, e consente stringhe multilinea racchiuse con "" ":

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

(nota le virgolette all'interno della stringa) e da Java:

String s2 = foobar.SWrap.bar ();

Se questo è più comodo ...?

Un altro approccio, se gestisci spesso testo lungo, che dovrebbe essere inserito nel tuo codice sorgente, potrebbe essere uno script, che prende il testo da un file esterno e lo avvolge come una stringa java multilinea come questa:

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

in modo che tu possa tagliarlo e incollarlo facilmente nella tua fonte.

Puoi concatenare i tuoi allegati in un metodo separato come:

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

In entrambi i casi, preferisci StringBuilderalla notazione più.

In realtà, la seguente è l'implementazione più pulita che ho visto finora. Usa un'annotazione per convertire un commento in una variabile stringa ...

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

Quindi, il risultato finale è che la variabile html contiene la stringa multilinea. Nessuna virgoletta, nessun vantaggio, nessuna virgola, solo una stringa pura.

Questa soluzione è disponibile al seguente URL ... http://www.adrianwalker.org/2011/12/java-multiline-string.html

Spero che aiuti!

Vedi Java Stringfier . Trasforma il tuo testo in un blocco Java StringBuilder che fuoriesce se necessario.

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

Un'alternativa che non ho ancora visto come risposta è la 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();

Anche il fatto che java.io.BufferedWriterabbia un newLine()metodo non è menzionato.

Se ti piace la guava di google tanto quanto me, può dare una rappresentazione abbastanza chiara e un modo semplice e piacevole per non codificare troppo i tuoi caratteri newline:

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

Uso Properties.loadFromXML(InputStream) . Non sono necessarie librerie esterne.

Meglio di un codice disordinato (poiché la manutenzione e il design sono la tua preoccupazione), è preferibile non utilizzare stringhe lunghe.

Inizia leggendo le proprietà xml:

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

allora puoi usare la tua stringa multilinea in un modo più gestibile ...

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

MultiLine.xml` si trova nella stessa cartella 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 .: Puoi usare <![CDATA[" ... "]]>per una stringa simile a xml.

Con build # 12 di accesso anticipato JDK / 12 , ora è possibile utilizzare stringhe multilinea in Java come segue:

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

e questo si traduce nel seguente output:

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

Modifica: rinviato a java 13

Una soluzione abbastanza efficiente e indipendente dalla piattaforma sarebbe usare la proprietà di sistema per i separatori di linea e la classe StringBuilder per costruire stringhe:

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

Una buona opzione.

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

    }

Questa è una domanda molto comune, quindi ho deciso di trasformare anche questa risposta in un articolo .

Java 13 e oltre

Le stringhe multilinea sono ora supportate in Java tramite blocchi di testo . In Java 13 e 14, questa funzione richiede di impostare il file––enable–preview opzione durante la creazione e l'esecuzione del progetto. Dai un'occhiata a questa documentazione Java per maggiori dettagli.

Ora, prima di Java 13, ecco come scrivere una query:

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

Grazie a Java 13 Text Blocks, puoi riscrivere questa query come segue:

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

Molto più leggibile, vero?

Supporto IDE

IntelliJ IDEA fornisce supporto per la trasformazione dei Stringblocchi di concatenazione legacy nel nuovo Stringformato multilinea :

JSON, HTML, XML

Il multilinea String è particolarmente utile quando si scrive JSON, HTML o XML.

Considera questo esempio usando la Stringconcatenazione per creare un valore letterale stringa JSON:

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" +
        "       }" +
        "   ]" +
        "}"
    )
);

A malapena puoi leggere il JSON a causa dei caratteri di escape e dell'abbondanza di virgolette doppie e segni più.

Con Java Text Blocks, l'oggetto JSON può essere scritto in questo modo:

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

Da quando ho usato C # nel 2004, volevo avere questa funzione in Java, e ora finalmente ce l'abbiamo.

Definire la mia stringa in un file delle proprietà?

Le stringhe multilinea non sono consentite nei file delle proprietà. È possibile utilizzare \ n nei file delle proprietà, ma non credo che sia una soluzione nel tuo caso.

So che questa è una vecchia domanda, tuttavia per gli sviluppatori intersted I letterali multi-linea saranno in # Java12

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

Suggerisco di utilizzare un'utilità come suggerito da ThomasP, quindi collegarla al processo di compilazione. È ancora presente un file esterno per contenere il testo, ma il file non viene letto in fase di esecuzione. Il flusso di lavoro è quindi:

1. Crea un'utilità "textfile to java code" e controlla il controllo versione
2. Su ogni build, eseguire l'utilità sul file di risorse per creare una fonte java rivista
3. Il sorgente Java contiene un'intestazione come class TextBlock {...seguita da una stringa statica che viene generata automaticamente dal file di risorse
4. Crea il file java generato con il resto del codice

Quando viene utilizzata una lunga serie di +, viene creato un solo StringBuilder, a meno che String non venga determinato al momento della compilazione, nel qual caso non viene utilizzato StringBuilder!

L'unica volta in cui StringBuilder è più efficiente è quando vengono utilizzate più istruzioni per costruire 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);

Nota: viene creato solo un 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

Per chiarire ulteriormente la mia domanda, non sono affatto preoccupato per le prestazioni. Sono preoccupato per manutenibilità e problemi di progettazione.

Rendilo il più chiaro e semplice possibile.