StringBuilder vs конкатенация в toString(): как работает под капотом

Онлайн-тренажер Python для начинающих

Изучайте Python легко и без перегрузки теорией. Решайте практические задачи с автоматической проверкой, получайте подсказки на русском языке и пишите код прямо в браузере — без необходимости что-либо устанавливать.

Начать курс

StringBuilder vs конкатенация в toString(): как это работает под капотом

Вы когда-нибудь задумывались, почему на Stack Overflow до сих пор кипят споры о том, как правильно писать toString() в Java? Одни разработчики свято верят, что StringBuilder — это единственный правильный путь. Другие спокойно используют обычную конкатенацию через плюс и не парятся. Кто же прав?

Давайте заглянем под капот Java-компилятора и JIT (Just-In-Time) оптимизатора. Вы узнаете, что на самом деле происходит, когда вы пишете str1 + str2 и почему в 2024 году ответ на этот вопрос может вас удивить.

Почему эта тема так популярна?

Вопрос "StringBuilder vs String concatenation in toString()" набрал тысячи просмотров на Stack Overflow не случайно. Каждый Java-разработчик хотя бы раз писал метод toString(). И каждый сталкивался с выбором: написать красиво через плюс или "правильно" через StringBuilder.

Миф о том, что конкатенация строк в Java всегда медленная, живёт уже больше 20 лет. И он был правдой... в эпоху Java 1.4 и Java 5. Но компиляторы не стоят на месте.

Что говорит спецификация Java?

Согласно спецификации Java Language Specification (JLS §15.18.1), оператор + для строк — это синтаксический сахар. Компилятор обязан преобразовать конкатенацию строк в эффективный код. Начиная с Java 5 (J2SE 5.0), компилятор javac автоматически заменяет конкатенацию на использование StringBuilder.

Давайте проверим это на практике.

Пример кода: простой toString()

Возьмём классический пример — метод toString() для класса Person:

public class Person {
    private String name;
    private int age;
    private String email;

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", email='" + email + '\'' +
                '}';
    }
}

Выглядит чисто и читаемо. Но как это выглядит в байт-коде?

Заглядываем в байт-код

Скомпилируем этот класс и посмотрим на байт-код с помощью javap -c Person.class:

public java.lang.String toString();
    Code:
       0: new           #7    // class java/lang/StringBuilder
       3: dup
       4: invokespecial #8    // Method StringBuilder."<init>":()V
       7: ldc           #9    // String "Person{name='"
       9: invokevirtual #10   // StringBuilder.append(String)
      12: aload_0
      13: getfield      #3    // Field name:Ljava/lang/String;
      16: invokevirtual #10   // StringBuilder.append(String)
      19: ldc           #11   // String "', age="
      21: invokevirtual #10   // StringBuilder.append(String)
      24: aload_0
      25: getfield      #4    // Field age:I
      28: invokevirtual #12   // StringBuilder.append(int)
      31: ldc           #13   // String ", email='"
      33: invokevirtual #10   // StringBuilder.append(String)
      36: aload_0
      37: getfield      #5    // Field email:Ljava/lang/String;
      40: invokevirtual #10   // StringBuilder.append(String)
      43: ldc           #14   // String "'}"
      45: invokevirtual #10   // StringBuilder.append(String)
      48: invokevirtual #15   // StringBuilder.toString():String
      51: areturn

Видите? Компилятор сам создал StringBuilder! Он создаёт новый объект StringBuilder, вызывает append() для каждой части строки, а затем toString(). То же самое, что вы написали бы вручную, но с более читаемым исходным кодом.

А что с явным StringBuilder?

Теперь напишем версию с явным StringBuilder:

@Override
public String toString() {
    StringBuilder sb = new StringBuilder();
    sb.append("Person{name='");
    sb.append(name);
    sb.append("', age=");
    sb.append(age);
    sb.append(", email='");
    sb.append(email);
    sb.append("'}");
    return sb.toString();
}

Байт-код этой версии будет практически идентичным. Разница только в том, что компилятор не создаёт StringBuilder за вас — вы делаете это сами. Но результат один и тот же.

Когда ручной StringBuilder всё ещё нужен?

Несмотря на оптимизации компилятора, есть ситуации, где StringBuilder в Java остаётся королём:

Циклы: Если вы собираете строку в цикле (например, for или while), компилятор не может оптимизировать конкатенацию. Каждая итерация создаёт новый StringBuilder — это катастрофа для производительности.
Условная сборка: Когда вы добавляете части строки в зависимости от условий, явный StringBuilder даёт больше контроля.
Очень длинные строки: Если вы собираете строку из сотен фрагментов, ручное управление размером буфера StringBuilder может быть полезным.

Практический тест производительности

Давайте проведём небольшой тест. Сравним три подхода в простом toString():

public class PerformanceTest {
    private String a = "Hello";
    private String b = "World";
    private int c = 42;

    // Подход 1: Конкатенация через +
    public String concat() {
        return "a=" + a + ", b=" + b + ", c=" + c;
    }

    // Подход 2: Явный StringBuilder
    public string builder() {
        return new StringBuilder()
                .append("a=").append(a)
                .append(", b=").append(b)
                .append(", c=").append(c)
                .toString();
    }

    // Подход 3: String.format (для справки)
    public string format() {
        return String.format("a=%s, b=%s, c=%d", a, b, c);
    }
}

Результаты (в наносекундах на вызов, после прогрева JIT):