путаница: строка неизменна, поэтому не используйте для объединения

String конкатенация с + оператором может рассматриваться как плохая практика, в определенных контекстах, то есть, если он не может быть автоматически заменен StringBuilder вызовов во время компиляции.

В общем случае, если ваше поле является константой или инициализировано только один раз, то конкатенация String с + отлично.

Однако, если вы динамически строит String и перекручивание/рекурсии, вы лучше с StringBuilder (или StringBuffer для поточно-сцеплений).

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

• Недопустимость: все операторы и котировки делают это раздражающим читать

• Ошибка: она слишком проста при изменении этого значения, чтобы опустить пробел из подстроки и сломать запрос

• Неудобно: вы не можете копировать запрос в инструмент SQL без необходимости останавливать и удалять все операторы и кавычки.

Вы могли бы извлечь такой SQL файл в файл конфигурации, либо файл свойств, либо XML (с использованием CDATA) могли бы работать. Вы можете увидеть примеры в Spring Integration - внешние запросы JDBC

+ считается неудачным, когда вы соединяете строки в цикле. Допустим, у вас есть

String s = "f";
for (int i=0; i<100; i++){
    s = s + "o";
}

В этом случае

s = s + "o";

будут скомпилированы как

s = new StringBuilder(f).append("o").toString();

поэтому на каждой итерации вы создаете новый StringBuilder, вы копируете текущий контент s в него, затем добавляете o и воссоздаете новый экземпляр String, вызывая toString который вы храните в ссылке s. Как вы видите, это много всего, что нужно сделать, особенно для копирования и создания нового экземпляра String, время выполнения которого зависит от длины строки.

Предпочтительный способ сделать это - создать собственный StringBuilder, добавить то, что вы хотите в цикле, и после завершения цикла создать новый объект String из содержимого StringBuilder. Что-то вроде

StringBuilder sb = new StringBuilder("f");
for (int i=0; i<100; i++){
    sb.append("o");
}
String s = sb.toString();

Но в вашем случае, поскольку вы работаете с константой компиляции, которая не может быть изменена, поэтому компилятор может выяснить, что

String str = " SELECT "
           + "field1, "
           + "field2, "
           + "field3  "
           + " FROM table1; ";

может быть не чем иным, как " SELECT field1, field2, field3 FROM table1; " поэтому он будет сцеплен во время компиляции, поэтому ваша str будет скомпилирована как

String str = " SELECT field1, field2, field3   FROM table1; ";

Ваш пример хорош, потому что он включает только литералы, а компилятор будет выполнять конкатенацию во время компиляции.

Но если бы у вас было:

String str = " SELECT "
           + "field1, "
           + someVariable
           + "field3  "
           + " FROM table1; ";

... тогда компилятор мог бы только обрабатывать часть этого для вас, приводя к этому во время выполнения:

String str = " SELECT field1, "
           + someVariable
           + "field3   FROM table1; ";

То, как это происходит во время выполнения, - это StringBuilder, который звучит великолепно, но, к сожалению, делается довольно неэффективно, фактически это:

StringBuilder sb1 = new StringBuilder();
sb1.append(" SELECT field1, ");
sb1.append(someVariable);
String temp = sb1.toString();
StringBuilder sb2 = new StringBuilder();
sb2.append(temp);
sb2.append("field3   FROM table1; ");
String str = sb2.toString();

Мало того, он создает несколько StringBuilder экземпляров и делать ненужные звонки в toString, но он использует конструктор по умолчанию, который только выделяет достаточно места для строки в 16 символов в его массиве ( в прошлом я проверил). Поэтому StringBuilder, вероятно, придется перераспределять свой внутренний массив хотя бы один раз. Блех, да? (Ждать его...)

Сравните с тем, что вы могли бы сделать сами:

String str = (new StringBuilder(200))
                .append(" SELECT " +
                        "field1, ")
                .append(someVariable)
                .append("field3  " +
                        " FROM table1; ")
                .toString();

Это намного эффективнее.

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

Так что это "лучше", если у вас есть проблема с производительностью, которая помогает решить эту проблему.

Это не "лучше", если вы этого не сделаете, так как код намного менее ясен.

Ничто из этого не имеет значения, если вы имеете дело только с литералами.

Я очень сомневаюсь, что field1 и field2 и table1 известны заранее, я предполагаю, что они являются параметрами для некоторой функции.

В этом случае вместо этого вы должны использовать StringBuilder. Даже если вы согласитесь со знаком "плюс", вы все равно (почти всегда) получите StringBuilder, просто посмотрите на байт-код. Вот ссылка:

"Реализация может решить выполнить преобразование и конкатенацию за один шаг, чтобы избежать создания и затем отбрасывания промежуточного объекта String. Чтобы увеличить производительность повторной конкатенации строк, компилятор Java может использовать класс StringBuffer или аналогичный метод для уменьшения числа промежуточные объекты String, созданные путем оценки выражения. " , 15.18.1

Просто помните, что будет штраф за выполнение, если вы будете петлять.