StringBuilder и StringBuffer в Java

Склеить 10 000 строк через s += part в цикле — значит 10 000 раз создать новый объект String и каждый раз заново скопировать всё, что накоплено. Код работает, но с ростом данных замедляется квадратично. Именно для таких задач в Java есть StringBuilder.

StringBuilder в Java — это класс изменяемой последовательности символов из пакета java.lang: методы append(), insert(), delete(), replace() и reverse() меняют содержимое того же объекта, не создавая новую строку. StringBuffer — его потокобезопасный (синхронизированный) аналог. Пакет java.lang подключается автоматически, поэтому import для StringBuilder не нужен. Неизменяемый класс String и его методы разобраны в уроке Java: класс String и его методы.

Отличия String, StringBuilder и StringBuffer

String неизменяем: любая «модификация» создаёт новый объект. StringBuilder и StringBuffer изменяемы и меняют содержимое на месте. Разница между ними одна — методы StringBuffer синхронизированы (потокобезопасны), а StringBuilder — нет, поэтому в однопоточном коде StringBuilder быстрее и используется по умолчанию.

Все три класса объявлены как final и реализуют интерфейс CharSequence, поэтому многие методы JDK принимают любой из них.

Когда использовать StringBuilder: конкатенация в цикле

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

public class ConcatInLoop {
    public static void main(String[] args) {
        // Плохо: на каждой итерации создаётся новая строка
        String s = "";
        for (int i = 0; i < 5; i++) {
            s += i;
        }
        System.out.println(s);

        // Хорошо: один объект, данные дописываются в буфер
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 5; i++) {
            sb.append(i);
        }
        System.out.println(sb.toString());
    }
}
// Вывод:
// 01234
// 01234

Результат одинаковый, но при 100 000 итерациях вариант с += копирует порядка n²/2 символов, а StringBuilder — линейное количество.

Для одиночного выражения вроде "Привет, " + name + "!" явный StringBuilder не нужен. До Java 8 включительно компилятор сам превращал такой + в цепочку StringBuilder.append(), а начиная с Java 9 (JEP 280) использует invokedynamic и StringConcatFactory, который работает не хуже ручного кода. Поэтому IntelliJ IDEA подсвечивает такой код инспекцией «StringBuilder can be replaced with String»: в одном выражении читаемый + лучше. Но в цикле оптимизация компилятора не помогает — там StringBuilder нужен явно. Соединить готовые строки через разделитель удобнее методом String.join().

Создание StringBuilder: конструкторы, length() и capacity()

StringBuilder создаётся через new одним из четырёх конструкторов. У объекта две разные «длины»: length() — сколько символов в строке сейчас, capacity() — размер внутреннего буфера, после заполнения которого буфер автоматически расширяется. Метода size() у StringBuilder нет.

public class StringBuilderExample1 {
    public static void main(String[] args) {
        StringBuilder stringBuilder = new StringBuilder("Hello");

        System.out.println("string = " + stringBuilder);
        System.out.println("length = " + stringBuilder.length());
        System.out.println("capacity = " + stringBuilder.capacity());

        StringBuilder empty = new StringBuilder();
        System.out.println("capacity = " + empty.capacity());
        empty.append("12345678901234567"); // 17 символов не помещаются в 16
        System.out.println("length = " + empty.length());
        System.out.println("capacity = " + empty.capacity());
    }
}
// Вывод:
// string = Hello
// length = 5
// capacity = 21
// capacity = 16
// length = 17
// capacity = 34

При переполнении буфер растёт примерно вдвое (старая capacity * 2 + 2, но не меньше требуемого), а старые данные копируются в новый массив. Если итоговый размер строки известен заранее, передайте его в конструктор new StringBuilder(1000) — это избавит от промежуточных копирований.

Методы StringBuilder: шпаргалка

Методы StringBuilder делятся на изменяющие объект (append, insert, delete, replace, reverse, setCharAt, setLength) и только читающие (charAt, indexOf, substring, length, toString). Изменяющие методы, кроме setCharAt и setLength, возвращают тот же StringBuilder, поэтому их можно вызывать цепочкой. У StringBuffer набор методов тот же.

Пример repeat() (Java 21): new StringBuilder().repeat("=", 10) даёт строку ========== — удобно для разделителей в консольном выводе.

Метод append()

Метод append() добавляет в конец StringBuilder строковое представление переданного значения: String, char, int, double, boolean, Object и т. д. Он возвращает тот же объект, поэтому вызовы удобно связывать в цепочку, а в конце получить строку через toString().

public class AppendExample {
    public static void main(String[] args) {
        int a = 42;
        StringBuilder sb = new StringBuilder(40);

        String s = sb.append("a = ").append(a).append('!').toString();
        System.out.println(s);

        String name = null;
        StringBuilder greeting = new StringBuilder("Привет, ");
        greeting.append(name);
        System.out.println(greeting);

        // greeting.append(null); // ошибка компиляции: reference to append is ambiguous
    }
}
// Вывод:
// a = 42!
// Привет, null

Переменная со значением null не вызывает исключения — добавляется текст "null". А литерал null напрямую не компилируется: подходят сразу несколько перегрузок (append(String), append(StringBuffer), append(char[])), и компилятор не может выбрать одну.

Метод insert()

Метод insert(offset, value) вставляет значение перед символом с индексом offset, сдвигая остаток строки вправо. Отдельного метода prepend() в Java нет: добавление в начало строки делается через insert(0, ...).

public class InsertExample {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("I Java!");

        sb.insert(2, "like ");
        System.out.println(sb);

        sb.insert(0, ">> ");      // добавление в начало
        System.out.println(sb);

        sb.insert(sb.length(), 21); // вставка в конец работает как append
        System.out.println(sb);

        sb.insert(100, "x");      // offset больше длины
    }
}
// Вывод:
// I like Java!
// >> I like Java!
// >> I like Java!21
// Exception in thread "main" java.lang.StringIndexOutOfBoundsException: ...

Допустимый offset — от 0 до length() включительно. Учтите, что вставка в начало длинной строки сдвигает все символы, поэтому многократный insert(0, ...) в цикле так же медленен, как +=; лучше добавлять через append() и один раз вызвать reverse() или собрать части в другом порядке.

Методы charAt(), setCharAt() и setLength()

Метод charAt(index) возвращает символ по индексу (нумерация с нуля), setCharAt(index, ch) заменяет его прямо в объекте, а setLength(n) обрезает строку до n символов. В отличие от String, где для замены одного символа приходится создавать новую строку, здесь изменение происходит на месте.

public class SetCharAtExample {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Hello");
        System.out.println(sb);
        System.out.println("charAt(1) = " + sb.charAt(1));

        sb.setCharAt(1, 'i');
        System.out.println(sb);

        sb.setLength(2);
        System.out.println(sb);

        sb.setLength(0);  // очистка
        System.out.println("length = " + sb.length());
    }
}
// Вывод:
// Hello
// charAt(1) = e
// Hillo
// Hi
// length = 0

Если передать в setLength() число больше текущей длины, строка дополнится невидимыми символами '\u0000', а не пробелами — при выводе это выглядит как «пустота», но length() вырастет.

Методы delete() и deleteCharAt()

Метод delete(start, end) удаляет символы с индекса start включительно по end не включительно, deleteCharAt(index) удаляет один символ. Если end больше длины строки, он молча обрезается до length(), а вот неверный start приводит к StringIndexOutOfBoundsException.

public class DeleteExample {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("This is a test.");

        sb.delete(4, 7);
        System.out.println("После delete: " + sb);

        sb.deleteCharAt(0);
        System.out.println("После deleteCharAt: " + sb);

        sb.delete(3, 100); // end больше длины — исключения нет
        System.out.println("После delete(3, 100): " + sb);
    }
}
// Вывод:
// После delete: This a test.
// После deleteCharAt: his a test.
// После delete(3, 100): his

Удобный приём — убрать лишний разделитель после цикла: sb.setLength(sb.length() - 2) или sb.delete(sb.length() - 2, sb.length()) для хвоста ", ". Перед этим проверьте, что строка не пуста, иначе получите исключение.

Метод replace()

Метод replace(start, end, str) заменяет символы с start по end - 1 на строку str, причём её длина может отличаться от длины заменяемого фрагмента. Это замена по позиции, а не по содержимому: в отличие от String.replace(), StringBuilder не ищет подстроку сам.

public class ReplaceExample {
    public static void main(String[] args) {
        StringBuilder stringBuilder = new StringBuilder("Это простой тест.");
        stringBuilder.replace(4, 11, "был");
        System.out.println("После замены: " + stringBuilder);
    }
}
// Вывод:
// После замены: Это был тест.

Чтобы заменить фрагмент по тексту, сначала найдите его позицию через indexOf(), а затем вызовите replace(pos, pos + old.length(), newText).

Метод reverse()

Метод reverse() переворачивает последовательность символов и возвращает тот же объект. Это самый короткий способ развернуть строку в Java, но важно помнить: меняется сам StringBuilder, а не создаётся копия.

public class ReverseExample {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("abcdef");

        String reversed = sb.reverse().toString();
        System.out.println(reversed);
        System.out.println(sb); // исходный объект тоже перевёрнут
    }
}
// Вывод:
// fedcba
// fedcba

Символы за пределами базовой плоскости Unicode (например, эмодзи) хранятся как суррогатные пары из двух char; reverse() обрабатывает такую пару как единое целое и не ломает символ.

Поиск и получение строки: indexOf(), substring(), toString()

Методы indexOf(), lastIndexOf() и substring() у StringBuilder работают так же, как у String, и не меняют объект. Метод toString() преобразует StringBuilder в String: создаёт новую неизменяемую строку с текущим содержимым.

public class SearchExample {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Java StringBuilder Java");

        System.out.println(sb.indexOf("Java"));
        System.out.println(sb.lastIndexOf("Java"));
        System.out.println(sb.indexOf("Java", 1));
        System.out.println(sb.substring(5, 18));
        System.out.println(sb.length()); // substring не изменил объект

        String result = sb.toString();
        sb.append("!");
        System.out.println(result);      // строка не зависит от дальнейших изменений
    }
}
// Вывод:
// 0
// 19
// 19
// StringBuilder
// 23
// Java StringBuilder Java

У indexOf() в StringBuilder нет перегрузки для char: вызов sb.indexOf('J') не скомпилируется, нужно писать sb.indexOf("J"). Подробнее о поиске и извлечении подстрок в String — в уроке о классе String.

Сравнение StringBuilder: equals(), compareTo() и contentEquals()

Классы StringBuilder и StringBuffer не переопределяют методы equals() и hashCode() — используется реализация класса Object, то есть сравниваются ссылки. Два builder-а с одинаковым текстом не равны по equals().

public class StringBuilderEquals {
    public static void main(String[] args) {
        StringBuilder sb1 = new StringBuilder("Hello");
        StringBuilder sb2 = new StringBuilder("Hello");

        System.out.println(sb1.equals(sb2));
        System.out.println(sb1 == sb2);

        // Правильные способы сравнить содержимое:
        System.out.println(sb1.toString().equals(sb2.toString()));
        System.out.println(sb1.compareTo(sb2) == 0);    // Java 11+
        System.out.println("Hello".contentEquals(sb1)); // String vs StringBuilder
    }
}
// Вывод:
// false
// false
// true
// true
// true

Начиная с Java 11 StringBuilder и StringBuffer реализуют Comparable, поэтому их можно сравнивать через compareTo() и сортировать. Логика результата та же, что у String.compareTo(): отрицательное число, ноль или положительное. Из-за отсутствия equals()/hashCode() по содержимому StringBuilder нельзя использовать как ключ HashMap или элемент HashSet — кладите туда sb.toString().

На чём чаще всего ошибаются

Большинство ошибок с StringBuilder связано с тем, что его путают с String: ждут сравнения по содержимому, копии при изменении или не замечают перегрузку с int. Пять типичных промахов, которые встречаются и в коде, и на собеседованиях:

1. Сравнение через equals(). sb1.equals(sb2) сравнивает ссылки и вернёт false даже для одинакового текста. Используйте compareTo() или toString().equals() (см. раздел о сравнении).
2. new StringBuilder('a'). Символ превращается в int, и создаётся пустой builder с capacity 97 (см. раздел о конструкторах).
3. Ожидание копии после reverse(), append(), delete(). Эти методы меняют исходный объект. Если исходный текст нужен, сохраните toString() до изменения или создайте копию new StringBuilder(sb).
4. Создание StringBuilder внутри цикла. for (...) { StringBuilder sb = new StringBuilder(); ... } теряет весь смысл: объект должен создаваться один раз до цикла.
5. StringBuilder ради одного выражения. new StringBuilder().append(a).append(b).toString() вместо a + b только усложняет код: компилятор и так оптимизирует конкатенацию в одном выражении.