Что такое StringBuilder?

StringBuilder: мутируемый класс для работы со строками

Что такое StringBuilder?

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

Ключевые характеристики

• Мутируемость — можно изменять содержимое после создания
• Производительность — не создаёт новые объекты при каждом изменении
• Буфер — хранит символы в динамическом массиве
• Не потокобезопасен — в отличие от StringBuffer
• Современный выбор — предпочтительнее StringBuffer в однопоточном коде

Почему StringBuilder, а не String?

String — иммутируемая:

String str = "Hello";
str = str + " World";  // Создаёт новый объект String!
str = str + " Java";   // Ещё один новый объект!

// Происходит:
// 1. str = new String("Hello World");
// 2. str = new String("Hello World Java");
// Старые объекты выбрасываются в сборку мусора

StringBuilder — мутируемая:

StringBuilder sb = new StringBuilder("Hello");
sb.append(" World");  // Изменяет существующий объект
sb.append(" Java");   // Всё ещё один объект

// Результат: "Hello World Java"
// Никаких промежуточных объектов!

Основные методы StringBuilder

1. append() — добавление в конец

StringBuilder sb = new StringBuilder("Hello");
sb.append(" World");              // Hello World
sb.append(123);                   // Hello World123
sb.append(true);                  // Hello World123true
sb.append(3.14);                  // Hello World123true3.14

String result = sb.toString();    // "Hello World123true3.14"

2. insert() — вставка в определённую позицию

StringBuilder sb = new StringBuilder("Hello Java");
sb.insert(6, "Beautiful ");  // "Hello Beautiful Java"
sb.insert(0, "Say: ");      // "Say: Hello Beautiful Java"

3. delete() / deleteCharAt() — удаление

StringBuilder sb = new StringBuilder("Hello World");
sb.delete(5, 11);        // "Hello" (удалить с 5 по 11)

StringBuilder sb2 = new StringBuilder("Hello");
sb2.deleteCharAt(1);     // "Hllo" (удалить 'e')

4. replace() — замена

StringBuilder sb = new StringBuilder("Hello World");
sb.replace(6, 11, "Java");  // "Hello Java"

5. reverse() — развернуть

StringBuilder sb = new StringBuilder("Hello");
sb.reverse();              // "olleH"

6. length() — длина

StringBuilder sb = new StringBuilder("Hello");
System.out.println(sb.length());  // 5

7. charAt() — получить символ по индексу

StringBuilder sb = new StringBuilder("Hello");
System.out.println(sb.charAt(1));  // 'e'

8. setCharAt() — установить символ

StringBuilder sb = new StringBuilder("Hello");
sb.setCharAt(0, 'J');  // "Jello"

9. substring() — подстрока

StringBuilder sb = new StringBuilder("Hello World");
String sub = sb.substring(0, 5);  // "Hello"

Пример: эффективное построение строки

public class StringBuilderExample {
    // ❌ Неэффективно: создаёт много промежуточных объектов
    public static String slowConcatenation() {
        String result = "";
        for (int i = 0; i < 1000; i++) {
            result += "Item " + i + "\n";
            // Каждая итерация создаёт новый String объект!
        }
        return result;
    }
    
    // ✅ Эффективно: одно переиспользуемое изменяемое хранилище
    public static String fastConcatenation() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 1000; i++) {
            sb.append("Item ").append(i).append("\n");
            // Все операции на одном объекте
        }
        return sb.toString();
    }
    
    public static void main(String[] args) {
        // Измерение производительности
        long start = System.nanoTime();
        slowConcatenation();
        long slowTime = System.nanoTime() - start;
        
        start = System.nanoTime();
        fastConcatenation();
        long fastTime = System.nanoTime() - start;
        
        System.out.println("Slow: " + slowTime + " нс");
        System.out.println("Fast: " + fastTime + " нс");
        System.out.println("Разница: " + (slowTime / fastTime) + "x раз");
    }
}

Результат: StringBuilder часто быстрее в 10-100 раз для больших объёмов конкатенации.

StringBuilder vs StringBuffer

// Однопоточный код: используй StringBuilder
StringBuilder sb = new StringBuilder();
sb.append("Hello");
sb.append(" World");

// Многопоточный код: используй StringBuffer (если нужна синхронизация)
StringBuffer sbf = new StringBuffer();
sbf.append("Hello");
sbf.append(" World");

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

1. CSV строка

public String buildCSV(List<String> values) {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < values.size(); i++) {
        sb.append(values.get(i));
        if (i < values.size() - 1) {
            sb.append(",");
        }
    }
    return sb.toString();
}

// Использование
List<String> data = Arrays.asList("John", "Doe", "30");
String csv = buildCSV(data);  // "John,Doe,30"

2. HTML строка

public String buildHTML(String title, String content) {
    StringBuilder sb = new StringBuilder();
    sb.append("<html>\n");
    sb.append("<head><title>").append(title).append("</title></head>\n");
    sb.append("<body>\n");
    sb.append(content);
    sb.append("</body>\n");
    sb.append("</html>");
    return sb.toString();
}

3. JSON построение

public String buildJSON(String key, String value) {
    StringBuilder sb = new StringBuilder();
    sb.append("{");
    sb.append("\"key\":\"").append(key).append("\",");
    sb.append("\"value\":\"").append(value).append("\"")
    sb.append("}");
    return sb.toString();
}

4. Развёртывание строки

public boolean isPalindrome(String str) {
    StringBuilder reversed = new StringBuilder(str);
    reversed.reverse();
    return str.equals(reversed.toString());
}

// Использование
System.out.println(isPalindrome("racecar"));  // true
System.out.println(isPalindrome("hello"));    // false

Производительность: ёмкость буфера

public class StringBuilderCapacity {
    public static void main(String[] args) {
        // По умолчанию ёмкость = 16
        StringBuilder sb1 = new StringBuilder();
        System.out.println("Capacity: " + sb1.capacity());  // 16
        
        // Можно указать начальную ёмкость
        StringBuilder sb2 = new StringBuilder(100);
        System.out.println("Capacity: " + sb2.capacity());  // 100
        
        // При превышении ёмкости она удваивается
        StringBuilder sb3 = new StringBuilder(10);
        for (int i = 0; i < 30; i++) {
            sb3.append("x");
            if (i % 10 == 0) {
                System.out.println("After " + i + " appends: capacity = " + sb3.capacity());
            }
        }
    }
}

Вывод:

Capacity: 16
Capacity: 100
After 0 appends: capacity = 10
After 10 appends: capacity = 22
After 20 appends: capacity = 46
After 30 appends: capacity = 46

Когда использовать StringBuilder

✅ Используй StringBuilder:

• При конкатенации строк в цикле
• Построение JSON, XML, HTML
• Форматирование больших текстов
• Работа со строками в интенсивном коде

❌ Не используй StringBuilder:

• Для одной или двух конкатенаций (String достаточно)
• Когда не нужна строка (работаешь с символами отдельно)
• Если нужна потокобезопасность (используй StringBuffer)

Резюме

StringBuilder — это мутируемый класс для эффективного построения и модификации строк. Он избегает создания множества промежуточных String объектов и даёт лучшую производительность при работе со строками. Используй StringBuilder вместо конкатенации String при работе с большими объёмами данных.