Что будет если сконкатенировать Integer, приведенный методом toString со строкой?

Конкатенация Integer.toString() со строкой: детальный анализ

Отличный вопрос! Это проверяет понимание того как работает String конкатенация в Java и разницу между примитивами и их строковыми представлениями.

Простой ответ

Integer num = 42;
String result = num.toString() + " это число";
System.out.println(result); // "42 это число"

Результат: строка содержит числовое значение как текст

Подробное объяснение

Что происходит шаг за шагом

Integer num = 42;

// Шаг 1: Integer.toString() возвращает String
String stringNum = num.toString(); // "42" (объект String)

// Шаг 2: Конкатенация String + String
String result = stringNum + " это число"; // "42 это число"

// В итоге:
// result = "42 это число"
// result.getClass() = java.lang.String
// result.length() = 16

Как Java обрабатывает конкатенацию

Когда компилятор видит String + String, он преобразует это в:

// Оригинальный код
String result = num.toString() + " это число";

// Что делает компилятор (до Java 9):
StringBuilder sb = new StringBuilder();
sb.append(num.toString());
sb.append(" это число");
String result = sb.toString();

// Java 9+: invokedynamic (StringConcatFactory)
// Более оптимизировано, но логика та же

Различные сценарии

Сценарий 1: Integer.toString() явно

Integer number = 100;
String s1 = number.toString() + " юнитов"; // "100 юнитов"

Сценарий 2: Integer напрямую (без toString())

Integer number = 100;
String s2 = number + " юнитов"; // Автоматический toString()
// Результат тот же: "100 юнитов"

// Почему? Компилятор автоматически вызывает toString()
// для объектов в String конкатенации

Сценарий 3: null Integer

Integer number = null;
String s3 = number.toString() + " юнитов";
// Результат: NullPointerException!

// Но с прямой конкатенацией:
String s4 = number + " юнитов"; // "null юнитов"
// Это работает, потому что Java преобразует null в "null"

Сценарий 4: Множественная конкатенация

Integer a = 1;
Integer b = 2;
Integer c = 3;

String result = a.toString() + b.toString() + c.toString();
// Результат: "123"

// Внутренне это становится:
StringBuilder sb = new StringBuilder();
sb.append(a.toString());
sb.append(b.toString());
sb.append(c.toString());
String result = sb.toString();

Внутренняя реализация Integer.toString()

// Упрощённая версия реализации
public static String toString(int i) {
    if (i == Integer.MIN_VALUE) {
        return "-2147483648";
    }
    
    int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i);
    char[] buf = new char[size];
    getChars(i, size, buf);
    return new String(buf, true); // new String объект
}

// Используется буферизация и прямое заполнение char массива
// Это оптимизировано для производительности

Производительность и оптимизация

❌ НЕ ЭФФЕКТИВНО — многократная конкатенация:

// Создаёт 3 новых String объекта
String result = "";
for (Integer num : numbers) {
    result = result + num.toString() + ",";
}
// Временная сложность: O(n^2)

✅ ОПТИМАЛЬНО — используй StringBuilder:

// Создаёт 1 StringBuilder объект
StringBuilder sb = new StringBuilder();
for (Integer num : numbers) {
    sb.append(num).append(",");
}
String result = sb.toString();
// Временная сложность: O(n)

✅ МОДЕРНО — используй String.join():

String result = String.join(",", 
    numbers.stream()
        .map(Integer::toString)
        .collect(Collectors.toList())
);

Сравнение методов конвертирования Integer в String

Integer number = 42;

// Способ 1: Integer.toString()
String s1 = Integer.toString(number);
String s2 = Integer.toString(42);

// Способ 2: String.valueOf()
String s3 = String.valueOf(number);
String s4 = String.valueOf(42);

// Способ 3: + конкатенация
String s5 = number + "";
String s6 = "" + number;

// Способ 4: format
String s7 = String.format("%d", number);

// Все результаты одинаковые: "42"
// НО производительность разная!

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

// Самый быстрый способ
Integer.toString(num); // Прямой вызов
String.valueOf(num);    // Примерно такой же

// Медленнее
"" + num; // Создаёт StringBuilder и пустую строку

// Самый медленный
String.format("%d", num); // Парсинг format string

Типовая ошибка: неявное преобразование

// ❌ Опасно если number может быть null
Integer number = someMethod(); // может вернуть null
String s = number.toString(); // NullPointerException!

// ✅ Безопасно
String s = String.valueOf(number); // вернёт "null"

// ✅ Или проверка
String s = number != null ? number.toString() : "0";

Практический пример: сборка URL

public class UrlBuilder {
    public static String buildProductUrl(Integer productId, String category) {
        return "https://shop.com/products/" 
            + category 
            + "/" 
            + productId.toString(); 
        // Результат: "https://shop.com/products/electronics/42"
    }
}

Ключевые моменты

• Integer.toString() возвращает объект String
• Конкатенация создаёт новый String объект
• null Integer вызывает NullPointerException при toString()
• String.valueOf() безопаснее (обрабатывает null)
• StringBuilder оптимальнее для множественных конкатенаций
• Компилятор оптимизирует простую конкатенацию

Итог

Когда вы делаете:

Integer num = 42;
String result = num.toString() + " это число";

Получается обычная String переменная со значением "42 это число". Ничего волшебного, но важно понимать что под капотом используется StringBuilder для оптимизации.