Vindo do Perl, com certeza estou faltando o meio "aqui-documento" de criar uma string de várias linhas no código-fonte:

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

Em Java, tenho que ter aspas complicadas e sinais de mais em todas as linhas, pois concatenar minha sequência de múltiplas linhas do zero.

Quais são algumas alternativas melhores? Definir minha string em um arquivo de propriedades?

Editar : duas respostas dizem que StringBuilder.append () é preferível à notação positiva. Alguém poderia explicar por que eles pensam assim? Não parece mais preferível para mim. Estou procurando uma maneira de contornar o fato de que cadeias de linhas múltiplas não são uma construção de linguagem de primeira classe, o que significa que definitivamente não quero substituir uma construção de linguagem de primeira classe (concatenação de cadeias com mais) por chamadas de método.

Editar : para esclarecer mais a minha pergunta, não estou preocupado com o desempenho. Estou preocupado com questões de manutenção e design.

Stephen Colebourne criou uma proposta para adicionar seqüências de várias linhas no Java 7.

Além disso, o Groovy já tem suporte para seqüências de várias linhas .

Parece que você deseja fazer um literal multilinha, que não existe em Java.

Sua melhor alternativa serão cordas que são apenas + juntas. Algumas outras opções que as pessoas mencionaram (StringBuilder, String.format, String.join) só seriam preferíveis se você começasse com uma matriz de strings.

Considere isto:

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

Se você deseja a nova linha para seu sistema específico, é necessário usar System.lineSeparator() , ou você pode usar %nno String.format.

Outra opção é colocar o recurso em um arquivo de texto e apenas ler o conteúdo desse arquivo. Isso seria preferível para cadeias muito grandes, para evitar inchar desnecessariamente os arquivos de classe.

Em Eclipse, se você ativar a opção "text Fuga ao colar em um literal string" (em Preferências> Java> Editor> Typing) e colar uma cadeia multi-alinhada whithin citações, ele irá adicionar automaticamente "e \n" +para todas as suas linhas.

String str = "paste your text here";

Este é um encadeamento antigo, mas uma nova solução bastante elegante (com apenas quatro, talvez três pequenas desvantagens) é usar uma anotação personalizada.

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

Um projeto inspirado nesse trabalho está hospedado no GitHub:

https://github.com/benelog/multiline

Exemplo de código 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);
  }
}

As desvantagens são

1. que você precisa ativar o processador de anotação correspondente (fornecido).
2. que a variável String não pode ser definida como variável local Projeto Check Literal String String onde você pode definir variáveis ​​como variáveis ​​locais
3. essa String não pode conter outras variáveis, como no Visual Basic .Net com literal XML (<%= variable %> ) :-)
4. esse literal String é delimitado pelo comentário JavaDoc (/ **)

E você provavelmente precisará configurar o Eclipse / Intellij-Idea para não reformatar automaticamente seus comentários do Javadoc.

Pode-se achar estranho (os comentários do Javadoc não são projetados para incorporar nada além de comentários), mas como essa falta de cadeia de linhas multilinhas no Java é realmente irritante no final, acho que essa é a pior solução.

Outra opção pode ser armazenar seqüências longas em um arquivo externo e ler o arquivo em uma sequência.

Isso é algo que você nunca deve usar sem pensar no que está fazendo. Mas para scripts únicos, usei isso com grande sucesso:

Exemplo:

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

Código:

// 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

O Java 8 adicionou um novo método estático ao java.lang.Stringqual oferece uma alternativa um pouco melhor:

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

Usando isso:

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

O JEP 355: Blocos de Texto (Visualização) visa cobrir essa funcionalidade, atualmente está direcionando o JDK 13 como um recurso de visualização. Permitindo escrever algo como:

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

Antes deste JEP, no JDK12, o JEP 326: literais de cadeia bruta visava implementar um recurso semelhante, mas foi finalmente retirado.

Se você definir suas strings em um arquivo de propriedades, ficará muito pior. IIRC, será semelhante a:

string:text\u000atext\u000atext\u000a

Geralmente, é uma idéia razoável não incorporar grandes cadeias na origem. Convém carregá-los como recursos, talvez em XML ou em um formato de texto legível. Os arquivos de texto podem ser lidos em tempo de execução ou compilados na fonte Java. Se você acabar colocando-os na fonte, sugiro colocar o item +na frente e omitir novas linhas desnecessárias:

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

Se você possui novas linhas, convém usar o método de junção ou formatação:

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

As vantagens são convertidas em StringBuilder.append, exceto quando as duas cadeias são constantes, para que o compilador possa combiná-las em tempo de compilação. Pelo menos, é assim no compilador da Sun, e eu suspeitaria mais, se não todos os outros compiladores fariam o mesmo.

Assim:

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

normalmente gera exatamente o mesmo código que:

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

Por outro lado:

String c="Hello"+"Goodbye";

é o mesmo que:

String c="HelloGoodbye";

Ou seja, não há penalidade em quebrar seus literais de string em várias linhas com sinais de adição para facilitar a leitura.

No IntelliJ IDE, você só precisa digitar:

""

Posicione o cursor entre aspas e cole sua string. O IDE o expandirá em várias linhas concatenadas.

Infelizmente, o Java não possui literais de cadeia de várias linhas. Você precisa concatenar literais de sequência (usando + ou StringBuilder sendo as duas abordagens mais comuns para isso) ou ler a sequência em um arquivo separado.

Para literais de grandes cadeias de caracteres de várias linhas, eu estaria inclinado a usar um arquivo separado e a ler usando getResourceAsStream()(um método doClass classe). Isso facilita a localização do arquivo, pois você não precisa se preocupar com o diretório atual e o local em que seu código foi instalado. Também facilita o empacotamento, porque você pode realmente armazenar o arquivo no seu arquivo jar.

Suponha que você esteja em uma classe chamada Foo. Basta fazer algo assim:

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

O outro incômodo é que o Java não possui um método padrão "leia todo o texto deste Reader em uma String". É muito fácil escrever:

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

Mas, a melhor alternativa é usar String.format

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

Como o Java (ainda) não suporta nativamente seqüências de várias linhas, a única maneira, no momento, é contorná-lo usando uma das técnicas mencionadas acima. Criei o seguinte script Python usando alguns dos truques mencionados acima:

import sys
import string
import os

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

Coloque isso em um arquivo chamado javastringify.py e sua string em um arquivo mystring.txt e execute-o da seguinte maneira:

cat mystring.txt | python javastringify.py

Você pode copiar a saída e colá-la no seu editor.

Modifique isso conforme necessário para lidar com casos especiais, mas isso funciona para minhas necessidades. Espero que isto ajude!

Você pode usar o código scala, que é compatível com java, e permite Strings de várias linhas incluídas em "" ":

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

(observe as aspas dentro da string) e de java:

String s2 = foobar.SWrap.bar ();

Se isso é mais confortável ...?

Outra abordagem, se você costuma manipular texto longo, que deve ser colocado em seu código-fonte, pode ser um script, que pega o texto de um arquivo externo e o envolve como uma cadeia de linhas-java como esta:

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

para que você possa recortar e colar facilmente em sua fonte.

Você pode concatenar seus anexos em um método separado, como:

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

De qualquer forma, prefira StringBuildera notação de mais.

Na verdade, a seguir é a implementação mais limpa que vi até agora. Ele usa uma anotação para converter um comentário em uma variável de string ...

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

Portanto, o resultado final é que a variável html contém a cadeia de linhas múltiplas. Sem aspas, sem vantagens, sem vírgulas, apenas string pura.

Esta solução está disponível no seguinte URL ... http://www.adrianwalker.org/2011/12/java-multiline-string.html

Espero que ajude!

Consulte Java Stringfier . Transforma seu texto em um bloco java StringBuilder, escapando, se necessário.

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

Uma alternativa que ainda não vi como resposta é a 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();

Além disso, o fato de java.io.BufferedWriterter um newLine()método não é mencionado.

Se você gosta da goiaba do google tanto quanto eu, ela pode fornecer uma representação bastante limpa e uma maneira fácil e agradável de não codificar também os caracteres da nova linha:

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

Use Properties.loadFromXML(InputStream). Não há necessidade de bibliotecas externas.

Melhor que um código confuso (como a manutenção e o design são sua preocupação), é preferível não usar seqüências longas.

Comece lendo as propriedades xml:

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

então você pode usar sua sequência multilinha de uma maneira mais sustentável ...

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

O MultiLine.xml` fica localizado na mesma pasta 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 .: Você pode usar <![CDATA["... "]]>para string semelhante a xml.

Com o JDK / 12, versão 12 do acesso antecipado , agora é possível usar seqüências de múltiplas linhas em Java da seguinte maneira:

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

e isso resulta na seguinte saída:

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

Edit: Adiado para java 13

Uma solução bastante eficiente e independente da plataforma seria usar a propriedade do sistema para separadores de linha e a classe StringBuilder para criar cadeias:

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

Uma boa opção.

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

    }

Essa é uma pergunta muito comum, então decidi transformar essa resposta em um artigo também .

Java 13 e além

As cadeias de linhas múltiplas agora são suportadas em Java por meio de blocos de texto . Nos Java 13 e 14, esse recurso requer que você defina a ––enable–previewopção ao criar e executar seu projeto. Confira esta documentação Java para obter mais detalhes.

Agora, antes do Java 13, é assim que você escreveria uma consulta:

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

Graças ao Java 13 Text Blocks, você pode reescrever esta consulta da seguinte maneira:

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

Muito mais legível, certo?

Suporte IDE

O IntelliJ IDEA fornece suporte para transformar Stringblocos de concatenação herdados no novo Stringformato de múltiplas linhas:

JSON, HTML, XML

A multilinha String é especialmente útil ao escrever JSON, HTML ou XML.

Considere este exemplo usando a Stringconcatenação para criar um literal de string 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" +
        "       }" +
        "   ]" +
        "}"
    )
);

Você mal consegue ler o JSON devido aos caracteres de escape e à abundância de aspas duplas e sinais de adição.

Com os blocos de texto Java, o objeto JSON pode ser escrito assim:

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

Desde que usei o C # em 2004, estou querendo ter esse recurso em Java, e agora finalmente o temos.

Definir minha string em um arquivo de propriedades?

Cadeias de linhas múltiplas não são permitidas em arquivos de propriedades. Você pode usar \ n nos arquivos de propriedades, mas não acho que seja uma solução muito boa no seu caso.

Eu sei que essa é uma pergunta antiga, no entanto, para desenvolvedores interessados, literais de várias linhas estarão em # Java12

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

Sugiro usar um utilitário, conforme sugerido por ThomasP, e depois vincular isso ao seu processo de compilação. Um arquivo externo ainda está presente para conter o texto, mas o arquivo não é lido no tempo de execução. O fluxo de trabalho é então:

1. Crie um utilitário 'arquivo de texto para código java' e verifique o controle de versão
2. Em cada construção, execute o utilitário no arquivo de recursos para criar uma fonte java revisada
3. A fonte Java contém um cabeçalho como class TextBlock {...seguido por uma sequência estática gerada automaticamente a partir do arquivo de recurso
4. Crie o arquivo java gerado com o restante do seu código

Quando uma série longa de + é usada, apenas um StringBuilder é criado, a menos que o String seja determinado no momento da compilação, caso em que nenhum StringBuilder é usado!

O único momento em que StringBuilder é mais eficiente é quando várias instruções são usadas para construir a 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: Apenas um StringBuilder é criado.

  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

Para esclarecer melhor minha pergunta, não estou preocupado com o desempenho. Estou preocupado com a manutenção e os problemas de design.

Deixe o mais claro e simples possível.