Исходя из Perl, я уверен, что мне не хватает средства «здесь-документ» для создания многострочной строки в исходном коде:

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

В Java у меня должны быть громоздкие кавычки и знаки плюс в каждой строке, поскольку я объединяю свою многострочную строку с нуля.

Какие есть лучшие альтернативы? Определить мою строку в файле свойств?

Изменить : два ответа говорят, что StringBuilder.append () предпочтительнее, чем нотации плюс. Кто-нибудь может уточнить, почему они так думают? Это не выглядит более предпочтительным для меня вообще. Я ищу способ обойти тот факт, что многострочные строки не являются языковой конструкцией первого класса, а это значит, что я определенно не хочу заменять языковую конструкцию первого класса (конкатенация строк с плюсом) вызовами методов.

Изменить : Чтобы уточнить мой вопрос дальше, я не беспокоюсь о производительности вообще. Я обеспокоен вопросами ремонтопригодности и дизайна.

Стивен Колебурн создал предложение о добавлении многострочных строк в Java 7.

Кроме того, в Groovy уже есть поддержка многострочных строк .

Звучит так, как будто вы хотите создать многострочный литерал, которого нет в 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.lineSeparator(), или вы можете использовать %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);
  }
}

Недостатки

1. что вы должны активировать соответствующий (предоставленный) процессор аннотаций.
2. эта строковая переменная не может быть определена как локальная переменная Проверьте проект Raw String Literals, где вы можете определить переменные как локальные переменные
3. эта строка не может содержать другие переменные, как в Visual Basic .Net с XML literal ( <%= variable %>) :-)
4. этот строковый литерал ограничен комментарием JavaDoc (/ **)

И вам, вероятно, придется настроить Eclipse / Intellij-Idea, чтобы не переформатировать автоматически ваши комментарии Javadoc.

Это может показаться странным (комментарии Javadoc не предназначены для встраивания чего-либо, кроме комментариев), но поскольку отсутствие многострочной строки в Java действительно раздражает в конце, я считаю, что это наименее худшее решение.

Другим вариантом может быть сохранение длинных строк во внешнем файле и чтение файла в строку.

Это то, что вы никогда не должны использовать, не задумываясь о том, что он делает. Но для одноразовых сценариев я использовал это с большим успехом:

Пример:

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

Код:

// From: http://blog.efftinge.de/2008/10/multi-line-string-literals-in-java.html
// Takes a comment (/**/) and turns everything inside the comment to a string that is returned from S()
public static String S() {
    StackTraceElement element = new RuntimeException().getStackTrace()[1];
    String name = element.getClassName().replace('.', '/') + ".java";
    StringBuilder sb = new StringBuilder();
    String line = null;
    InputStream in = classLoader.getResourceAsStream(name);
    String s = convertStreamToString(in, element.getLineNumber());
    return s.substring(s.indexOf("/*")+2, s.indexOf("*/"));
}

// From http://www.kodejava.org/examples/266.html
private static String convertStreamToString(InputStream is, int lineNum) {
    /*
     * To convert the InputStream to String we use the BufferedReader.readLine()
     * method. We iterate until the BufferedReader return null which means
     * there's no more data to read. Each line will appended to a StringBuilder
     * and returned as String.
     */
    BufferedReader reader = new BufferedReader(new InputStreamReader(is));
    StringBuilder sb = new StringBuilder();

    String line = null; int i = 1;
    try {
        while ((line = reader.readLine()) != null) {
            if (i++ >= lineNum) {
                sb.append(line + "\n");
            }
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            is.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    return sb.toString();
}

String.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!"
);

JEP 355. Текстовые блоки (предварительный просмотр) предназначены для охвата этой функциональности, в настоящее время он нацелен на JDK 13 в качестве функции предварительного просмотра. Позволяет написать что-то вроде:

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

До этого JEP, в JDK12, JEP 326: сырые строковые литералы стремились реализовать подобную функцию, но она была окончательно отозвана.

Если вы определите свои строки в файле свойств, это будет выглядеть намного хуже. 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 развернет ее на несколько объединенных строк.

К сожалению, в Java нет многострочных строковых литералов. Вы должны либо объединить строковые литералы (используя + или StringBuilder как два наиболее распространенных подхода к этому), либо прочитать строку из отдельного файла.

Для больших многострочных строковых литералов я был бы склонен использовать отдельный файл и читать его при использовании getResourceAsStream()(методClass класса). Это облегчает поиск файла, так как вам не нужно беспокоиться о текущем каталоге по сравнению с тем, где был установлен ваш код. Это также упрощает упаковку, потому что вы можете хранить файл в вашем jar-файле.

Предположим, вы в классе Foo. Просто сделайте что-то вроде этого:

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

Еще одно неудобство заключается в том, что в 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();
}

String newline = System.getProperty ("line.separator");
string1 + newline + string2 + newline + string3

Но лучшая альтернатива - использовать String.format

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

Поскольку Java (пока) не поддерживает нативные многострочные строки, на данный момент единственный способ это обойти, используя один из вышеупомянутых методов. Я построил следующий скрипт на Python, используя некоторые приемы, упомянутые выше:

import sys
import string
import os

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

Поместите это в файл с именем javastringify.py и свою строку в файл mystring.txt и запустите его следующим образом:

cat mystring.txt | python javastringify.py

Затем вы можете скопировать вывод и вставить его в свой редактор.

Измените это по мере необходимости для обработки любых особых случаев, но это работает для моих нужд. Надеюсь это поможет!

Вы можете использовать scala-код, который совместим с java и допускает многострочные строки, заключенные в "" ":

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

Это удобнее ...?

Другой подход, если вы часто обрабатываете длинный текст, который должен быть помещен в ваш исходный код, может быть сценарием, который берет текст из внешнего файла и упаковывает его в многострочную-java-String, например так:

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

так что вы можете легко вырезать и вставлять его в свой источник.

Вы можете объединить свои добавления отдельным методом, например:

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

В любом случае, предпочитайте StringBuilderплюс.

На самом деле, следующее является самой чистой реализацией, которую я видел до сих пор. Он использует аннотацию для преобразования комментария в строковую переменную ...

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

Таким образом, конечным результатом является то, что переменная html содержит многострочную строку. Без кавычек, без плюсов, без запятых, просто чистая строка.

Это решение доступно по следующему URL ... http://www.adrianwalker.org/2011/12/java-multiline-string.html

Надеюсь, это поможет!

Смотрите Java Stringfier . Превращает ваш текст в Java-блок StringBuilder, экранирующий при необходимости.

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

Альтернативой, которую я пока не видел в качестве ответа, является 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()метод, не упомянут.

Если вам нравится гуава в Google, как и я, он может дать довольно чистое представление и хороший и простой способ не жестко кодировать символы новой строки:

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

Использование Properties.loadFromXML(InputStream). Там нет необходимости для внешних библиотек.

Лучше, чем неаккуратный код (так как ваша забота о поддержке и дизайне), желательно не использовать длинные строки.

Начните с чтения свойств xml:

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

тогда вы можете использовать вашу многострочную строку более удобным способом ...

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

MultiLine.xml` располагается в той же папке YourClass:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">

<properties>
    <entry key="Super Duper UNIQUE Key">
       MEGA
       LONG
       MULTILINE
    </entry>
</properties>

PS: Вы можете использовать <![CDATA["... "]]>для xml-подобной строки.

С JDK / 12 раннего доступа build # 12 , теперь можно использовать многострочные строки в Java следующим образом:

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

и это приводит к следующему выводу:

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

Редактировать: Отложено на Java 13

Довольно эффективное и независимое от платформы решение будет использовать системное свойство для разделителей строк и класс 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();

Один хороший вариант.

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

    }

Это очень распространенный вопрос, поэтому я решил превратить этот ответ в статью .

Java 13 и выше

Многострочные строки теперь поддерживаются в Java с помощью текстовых блоков . В Java 13 и 14 эта функция требует, чтобы вы установили ––enable–previewопцию при сборке и запуске вашего проекта. Проверьте эту документацию Java для более подробной информации.

Теперь, до Java 13, вот как бы вы написали запрос:

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

Благодаря Java 13 Text Blocks вы можете переписать этот запрос следующим образом:

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

Гораздо более читабельно, верно?

Поддержка IDE

IntelliJ IDEA поддерживает преобразование устаревших Stringблоков сцепления в новый многострочный Stringформат:

JSON, HTML, XML

Многострочный Stringособенно полезен при написании JSON, HTML или XML.

Рассмотрим этот пример с использованием 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" +
        "       }" +
        "   ]" +
        "}"
    )
);

Вы едва можете прочитать JSON из-за экранирующих символов и обилия двойных кавычек и знаков плюс.

С помощью текстовых блоков Java объект 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
               }
           ]
        }
        """
    )
);

С тех пор, как я использовал C # в 2004 году, я хотел иметь эту функцию на Java, и теперь мы наконец-то ее получили.

Определить мою строку в файле свойств?

Многострочные строки не допускаются в файлах свойств. Вы можете использовать \ n в файлах свойств, но я не думаю, что это большая часть решения в вашем случае.

Я знаю, что это старый вопрос, однако для заинтересованных разработчиков Многострочные литералы будут в # Java12

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

Я предлагаю использовать утилиту, предложенную ThomasP, а затем связать ее с процессом сборки. Внешний файл все еще присутствует, чтобы содержать текст, но файл не читается во время выполнения. Рабочий процесс тогда:

1. Создайте утилиту 'textfile to java code' и проверьте контроль версий
2. В каждой сборке запускайте утилиту для файла ресурсов, чтобы создать исправленный исходный код Java
3. Исходный код Java содержит заголовок class TextBlock {... статической строке, которая автоматически генерируется из файла ресурсов.
4. Создайте сгенерированный файл Java с остальным кодом

Когда используется длинная серия +, создается только один StringBuilder, если только String не определен во время компиляции, и в этом случае StringBuilder не используется!

Единственный раз, когда StringBuilder более эффективен, это когда несколько операторов используются для создания String.

String a = "a\n";
String b = "b\n";
String c = "c\n";
String d = "d\n";

String abcd = a + b + c + d;
System.out.println(abcd);

String abcd2 = "a\n" +
        "b\n" +
        "c\n" +
        "d\n";
System.out.println(abcd2);

Примечание. Создан только один StringBuilder.

  Code:
   0:   ldc     #2; //String a\n
   2:   astore_1
   3:   ldc     #3; //String b\n
   5:   astore_2
   6:   ldc     #4; //String c\n
   8:   astore_3
   9:   ldc     #5; //String d\n
   11:  astore  4
   13:  new     #6; //class java/lang/StringBuilder
   16:  dup
   17:  invokespecial   #7; //Method java/lang/StringBuilder."<init>":()V
   20:  aload_1
   21:  invokevirtual   #8; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   24:  aload_2
   25:  invokevirtual   #8; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   28:  aload_3
   29:  invokevirtual   #8; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   32:  aload   4
   34:  invokevirtual   #8; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   37:  invokevirtual   #9; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;
   40:  astore  5
   42:  getstatic       #10; //Field java/lang/System.out:Ljava/io/PrintStream;
   45:  aload   5
   47:  invokevirtual   #11; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   50:  ldc     #12; //String a\nb\nc\nd\n
   52:  astore  6
   54:  getstatic       #10; //Field java/lang/System.out:Ljava/io/PrintStream;
   57:  aload   6
   59:  invokevirtual   #11; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   62:  return

Чтобы уточнить мой вопрос дальше, я не беспокоюсь о производительности вообще. Я обеспокоен вопросами ремонтопригодности и дизайна.

Сделайте это как можно более понятным и простым.