Как при сложении пятисот строк, получить одну новую строку

Конкатенация строк в Java

При работе с большим количеством строк (500+) выбор метода конкатенации критически влияет на производительность. Рассмотрю все основные подходы с их преимуществами и недостатками.

1. StringBuilder (РЕКОМЕНДУЕМЫЙ ПОДХОД)

Для сложения 500 и более строк StringBuilder — оптимальный выбор:

StringBuilder sb = new StringBuilder();
for (String str : strings) {
    sb.append(str);
}
String result = sb.toString();

Преимущества:

• Линейная сложность O(n), где n — количество строк
• Буферизация результата в памяти
• Быстрое добавление элементов
• Потокоопасность достигается через synchronized (StringBuffer)

Параметр initialCapacity:

// Если знаешь примерный размер — указывай
StringBuilder sb = new StringBuilder(5000);
for (String str : strings) {
    sb.append(str);
}

Это избегает переаллокации памяти при превышении текущей ёмкости.

2. String.join() (Java 8+)

Старт с Java 8 есть удобный метод:

String result = String.join("", strings);

Одна строка вместо цикла! Под капотом использует StringBuilder, поэтому производительность аналогична.

С разделителем:

String result = String.join(", ", strings); // Строки через запятую

3. Оператор + (ИЗБЕГАЙ!)

// ❌ ПЛОХО - не делай так для 500 строк!
String result = "";
for (String str : strings) {
    result = result + str; // Создаёт новый объект каждый раз!
}

Почему это медленно:

• Каждая операция + создаёт новый объект String
• Старая строка копируется целиком + добавляется новая
• Сложность O(n²) — катастрофично для 500 строк!
• Пример: 500 строк = 500×501/2 = 125,250 операций копирования

4. StringBuffer (УСТАРЕЛО)

StringBuffer sb = new StringBuffer();
for (String str : strings) {
    sb.append(str);
}
String result = sb.toString();

Отличие от StringBuilder:

• Все методы synchronized
• Безопасен для многопоточности
• МЕДЛЕННЕЕ из-за синхронизации

Используй только если работаешь с потоками напрямую.

5. Streams API (Java 8+)

String result = strings.stream()
    .collect(Collectors.joining());

// С разделителем:
String result = strings.stream()
    .collect(Collectors.joining(", "));

Когда полезно:

• Нужна обработка элементов (filter, map)
• Код более функциональный
• Сложность всё ещё O(n)

Сравнение производительности

Для 500 строк по 100 символов каждая:

Практический пример

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class StringConcatenation {
    public static void main(String[] args) {
        List<String> strings = new ArrayList<>();
        for (int i = 0; i < 500; i++) {
            strings.add("String " + i + " ");
        }

        // Вариант 1: StringBuilder (самый явный)
        long start = System.currentTimeMillis();
        StringBuilder sb = new StringBuilder();
        for (String str : strings) {
            sb.append(str);
        }
        String result1 = sb.toString();
        System.out.println("StringBuilder: " + (System.currentTimeMillis() - start) + "ms");

        // Вариант 2: String.join() (самый лаконичный)
        start = System.currentTimeMillis();
        String result2 = String.join("", strings);
        System.out.println("String.join(): " + (System.currentTimeMillis() - start) + "ms");

        // Вариант 3: Streams (самый функциональный)
        start = System.currentTimeMillis();
        String result3 = strings.stream()
            .collect(Collectors.joining());
        System.out.println("Streams: " + (System.currentTimeMillis() - start) + "ms");
    }
}

Рекомендация для собеседования

Правильный ответ:

• StringBuilder для явного кода
• String.join() для лаконичности
• Никогда не использовать оператор +

Это показывает понимание сложности алгоритмов и управления памятью в Java.