Как объединять строки в Java: 7 способов и рекомендации

Введение

Много задач программирования сводится к манипуляциям с текстом: формирование сообщений, логов, SQL-запросов, шаблонов и т. п. Java предоставляет несколько встроенных способов объединения строк. Понимание их отличий помогает писать безопасный и быстрый код.

Определение: Конкатенация — связывание двух или более строк в одну.

Важно: некоторые методы чувствительны к null (например, String.concat(null) вызовет NullPointerException). Планируйте обработку null заранее.

Используйте оператор +

Оператор + — самый простой и распространённый способ. Он удобен для быстрых комментариев, вывода в консоль и компактных выражений.

Пример:

public class StringConcat_Java {  
    public static void main(String[] args)  
    {  
        String var1 = "Hello,";  
        String var2 = "My name is";  
        String var3 = "Advait";  
   
        System.out.println(var1 + " " + var2 + " " + var3);  
    }  
}

Плюсы:

• Очень читаемо для небольших случаев.

Минусы:

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

Когда не использовать: многократная конкатенация в больших циклах или сборка очень большой строки — используйте StringBuilder.

Объединение строк на нескольких строках с помощью +

Можно разделять строковые литералы на несколько строк в коде, соединяя их +.

public class StringConcat_Java {  
    public static void main(String[] args)   
    {  
        String var1 = "Hello, " +  
            "My name is Advait." +  
            " " +  
            "I am a writer at MUO.";  
   
        System.out.println(var1);  
    }  
}

Совет по стилю: для длинных литералов используйте конкатенацию на уровне компилятора (литералы автоматически склеятся) или текстовые блоки (Java 15+) где уместно.

Используйте StringBuilder для многократных добавлений

StringBuilder оптимизирован для последовательного добавления фрагментов строки. Подходит при динамической сборке больших строк.

public class StringConcat_Java {  
    public static void main(String[] args)  
    {  
        StringBuilder strn_builder = new StringBuilder();  
   
        strn_builder.append("Hello,");   
        strn_builder.append(" I'm");  
        strn_builder.append(" Advait Singh");   
   
        System.out.println(strn_builder.toString());  
    }  
}  

Плюсы:

• Быстро при многократных append.
• Не создаёт промежуточных immutable-объектов, как + в цикле.

Минусы:

• Немного более многословен, чем +.
• Не потокобезопасен (в многопоточном окружении используйте StringBuffer).

Когда использовать: сборка больших сообщений, циклы, генерация текста.

Функция concat()

String.concat() объединяет две строки. Метод прост, но не принимает null.

• Работает только со String.
• Принимает один аргумент; можно цепочить вызовы: str1.concat(str2).concat(str3).

public class Stringconcat_Java {  
    public static void main(String[] args)  
    {  
        // Define the string values in var1 and var2  
        String var1 = "Hello, ";  
        String var2 = "My name is Advait Singh";  
   
        // var3 contains the concatenated value, wherein var1 is joined with var2  
        String var3 = var1.concat(var2);   
   
        // Print the final version stored in var3  
        System.out.println(var3);  
    }  
}

Подводные камни:

• Если второй аргумент равен null, будет NullPointerException.
• Менее гибок для большого числа частей, чем StringBuilder или String.join.

String.format() для форматируемых строк

String.format() подходит, когда нужно подставить значения по шаблону (форматирование). Он хорош для локализации и контроля формата.

public class Stringconcat_Java {  
    public static void main(String[] args)  
    {  
        // Define the string values in the first and second variable  
        String var1 = "Hello, ";  
        String var2 = "My name is Advait Singh";  
   
        // Use the format function to concatenate strings  
        String var3 = String.format("%s%s", var1, var2);   
   
        // Print the output stored in var3  
        System.out.println(var3);  
    }  
}

Плюсы:

• Читабельность при сложных шаблонах.
• Поддерживает локализацию (Locale).

Минусы:

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

String.join() для коллекций и разделителей

String.join(delimiter, parts…) объединяет произвольное число строк, вставляя разделитель между ними. Удобно для списков и CSV-подобных форматов.

public class Stringconcat_Java {  
    public static void main(String[] args)  
    {  
        // Create new strings and store them in var1 and var2 variables  
        String var1 = "Hello,";  
        String var2 = "My name is Advait";  
   
        // Use the String.join method to combine the strings  
        String var3 = String.join(" ", var1, var2);   
   
        System.out.println(var3);  
    }  
}  

.jpg)

Советы:

• String.join доступен начиная с Java 8.
• Для коллекций и стримов эквивалент — Collectors.joining().

Дополнительные варианты и нюансы

• StringBuffer — потокобезопасный аналог StringBuilder. Используйте, если объект разделяется между потоками и вы не можете обеспечить внешнюю синхронизацию.
• Текстовые блоки (text blocks) появились в Java 15 и помогают с многострочными литералами.
• При сборке SQL-запросов или HTML избегайте простого конкатенации без экранирования — это риск внедрения (инъекций). Используйте параметры или шаблонизаторы.

Когда методы дают неправильный результат или плохую производительность

• • в цикле: если в цикле вы делаете s = s + fragment, это часто приводит к созданию многих временных объектов; используйте StringBuilder.
• concat(null) — вызовет NullPointerException.
• Форматирование с неправильными спецификаторами (например, %d для строки) вызовет исключение.

Ментальные модели и эвристики

• Малые и редкие объединения → оператор + для простоты.
• Много добавлений/вложенные циклы → StringBuilder.
• Объединение коллекции с разделителем → String.join или Collectors.joining().
• Нужен шаблон/локализация → String.format.

Быстрая таблица совместимости

• Java 5: StringBuilder, String.format доступны.
• Java 8: String.join, Stream API.
• Java 15+: текстовые блоки (полезны для многострочных литералов).

Решающее дерево (Mermaid)

flowchart TD
  A[Нужно ли много операций?] -->|Нет| B[Используйте +]
  A -->|Да| C[Требуется потокобезопасность?]
  C -->|Да| D[Используйте StringBuffer]
  C -->|Нет| E[Используйте StringBuilder]
  B --> F[Нужно форматирование?]
  F -->|Да| G[Используйте String.format]
  F -->|Нет| H[OK]
  E --> I[Объединение коллекции?]
  I -->|Да| J[Используйте String.join или Collectors.joining]
  I -->|Нет| K[OK]

Чек-лист для ролей

• Разработчик:

  • Выбрать StringBuilder для накопления в цикле.
  • Проверять null перед String.concat().
  • Использовать Collectors.joining для стримов.

• Архитектор:

  • Убедиться, что логические строки формируются безопасно (экранование).
  • Предложить стандарты (когда +, когда StringBuilder).

• Ревьювер кода:

  • Ищите конкатенацию в горячих циклах.
  • Проверяйте формат-строки на соответствие типам.

Факт-бокс: ключевые версии и правила

• StringBuilder: появление в Java 5 (рекомендован для одиночного потока при накоплении).
• String.format: доступен с Java 5, полезен для локализации и шаблонов.
• String.join: добавлен в Java 8, удобен для коллекций.

Примеры альтернатив (короткие сниппеты)

Collectors.joining с потоками:

List parts = Arrays.asList("a","b","c");
String result = parts.stream().collect(Collectors.joining(","));

StringBuffer (потокобезопасно):

StringBuffer buf = new StringBuffer();
buf.append("a");
buf.append("b");
String res = buf.toString();

FAQ

Какой способ самый быстрый?

В большинстве случаев StringBuilder при многократных модификациях быстрее, чем повторяющийся оператор +. Для единичных выражений + удобен и компилируется эффективно.

Могу ли я использовать concat с null?

Нет. String.concat(null) вызовет NullPointerException. Проверяйте null или используйте Objects.toString(value, “”) для безопасной подстановки.

Когда лучше String.join вместо StringBuilder?

Если вы объединяете коллекцию строк и нужен разделитель — String.join или Collectors.joining удобнее и чище по коду.

Короткий глоссарий

• Конкатенация — объединение двух или более строк в одну.
• StringBuilder — класс для эффективного накопления строк в одном потоке.
• StringBuffer — потокобезопасный аналог StringBuilder.

Резюме

• Используйте + для простоты и читаемости в небольших выражениях.
• Для интенсивных операций и циклов — StringBuilder.
• Для коллекций с разделителем — String.join или Collectors.joining.
• Всегда учитывайте null и безопасность данных при формировании строк.

.jpg)