Полное руководство: преобразование String в int в Java

Преобразование строки в int в Java можно выполнить несколькими способами, при этом Integer.parseInt() и Integer.valueOf() являются наиболее распространенными подходами. Метод Integer.parseInt() напрямую преобразует строку в примитивное значение int, в то время как Integer.valueOf() возвращает объект Integer, который можно распаковать в int. Оба метода вызовут исключение NumberFormatException, если строка не представляет собой допустимое целое число.

Содержание

• Основные методы преобразования
• Обработка ошибок и валидация
• Вопросы производительности
• Рекомендации и лучшие практики
• Продвинутые сценарии преобразования

Основные методы преобразования

Использование Integer.parseInt()

Метод Integer.parseInt() является наиболее прямым способом преобразования строки в примитивное значение int:

String numberString = "1234";
int number = Integer.parseInt(numberString);
// number теперь равен 1234

Этот метод принимает строку в качестве входных данных и возвращает соответствующее значение int. Он является предпочтительным методом, когда вам нужно примитивное значение int, а не объект Integer.

Использование Integer.valueOf()

Метод Integer.valueOf() преобразует строку в объект Integer:

String numberString = "1234";
Integer number = Integer.valueOf(numberString);
// number - это объект Integer со значением 1234

Возвращаемый объект Integer затем можно распаковать в int при необходимости:

int primitiveValue = number; // автоматическая распаковка

Использование new Integer()

Хотя этот подход все еще доступен, конструктор устарел с Java 9 и его следует избегать:

// Устаревший подход - не используйте
Integer number = new Integer("1234");

Обработка ошибок и валидация

Обработка NumberFormatException

Оба метода parseInt() и valueOf() вызывают исключение NumberFormatException, когда строку невозможно разобрать как допустимое целое число:

String invalidString = "abc";
try {
    int number = Integer.parseInt(invalidString);
} catch (NumberFormatException e) {
    System.out.println("Недопустимый формат числа: " + e.getMessage());
}

Предварительная валидация с помощью регулярных выражений

Вы можете проверить строку перед преобразованием с помощью регулярных выражений:

import java.util.regex.Pattern;

String input = "1234";
if (Pattern.matches("-?\\d+", input)) {
    int number = Integer.parseInt(input);
} else {
    System.out.println("Строка не является допустимым целым числом");
}

Использование Optional для безопасного преобразования

Для более современных версий Java (8+) можно использовать Optional для обработки возможных сбоев преобразования:

import java.util.Optional;

public Optional<Integer> safeParseInt(String input) {
    try {
        return Optional.of(Integer.parseInt(input));
    } catch (NumberFormatException e) {
        return Optional.empty();
    }
}

// Использование
Optional<Integer> result = safeParseInt("1234");
if (result.isPresent()) {
    int number = result.get();
}

Вопросы производительности

Примитивы vs Объекты: производительность

• Integer.parseInt() обычно быстрее, так как напрямую возвращает примитивное значение int
• Integer.valueOf() создает объект Integer, что включает накладные расходы на выделение объекта
• Для критически важного по производительности кода предпочтительнее использовать parseInt(), когда вам нужны примитивные значения

Преимущества пула строк

Метод valueOf() использует кэш Integer (для значений между -128 и 127), возвращая кэшированные экземпляры вместо создания новых объектов:

Integer a = Integer.valueOf(127);
Integer b = Integer.valueOf(127);
// a == b равно true (один и тот же кэшированный экземпляр)

Integer c = new Integer(127);
Integer d = new Integer(127);
// c == d равно false (разные экземпляры)

Рекомендации и лучшие практики

Выбор правильного метода

Обработка null и пустых строк

Всегда корректно обрабатывайте null и пустые строки:

public int parseIntSafely(String input, int defaultValue) {
    if (input == null || input.trim().isEmpty()) {
        return defaultValue;
    }
    try {
        return Integer.parseInt(input.trim());
    } catch (NumberFormatException e) {
        return defaultValue;
    }
}

Использование try-with-Resources для сложного разбора

Для более сложных сценариев разбора рассмотрите возможность создания утилитарного класса:

public class NumberParser {
    public static int parseInt(String input) throws NumberFormatException {
        Objects.requireNonNull(input, "Входная строка не может быть null");
        String trimmed = input.trim();
        if (trimmed.isEmpty()) {
            throw new NumberFormatException("Пустая строка не может быть преобразована в целое число");
        }
        return Integer.parseInt(trimmed);
    }
}

Продвинутые сценарии преобразования

Обработка различных форматов чисел

Шестнадцатеричные строки

String hexString = "1F4"; // 500 в десятичной системе
int decimalValue = Integer.parseInt(hexString, 16);

Двоичные строки

String binaryString = "100111000100"; // 1234 в десятичной системе
int decimalValue = Integer.parseInt(binaryString, 2);

Восьмеричные строки

String octalString = "2322"; // 1234 в десятичной системе
int decimalValue = Integer.parseInt(octalString, 8);

BigDecimal для больших чисел

Для очень больших чисел, которые могут превышать диапазон int:

String largeNumber = "999999999999999999999999999999";
BigInteger bigInt = new BigInteger(largeNumber);
// Затем преобразуйте в int, если в пределах диапазона
try {
    int value = bigInt.intValueExact();
} catch (ArithmeticException e) {
    System.out.println("Число слишком большое для int");
}

Разбор чисел с учетом локали

Для чисел со специфичным для локали форматированием:

String formattedNumber = "1,234"; // В некоторых локалах запятая используется как разделитель тысяч
int number = Integer.parseInt(formattedNumber.replace(",", ""));

Использование Scanner для множественных преобразований

При разборе нескольких чисел из входных данных:

import java.util.Scanner;

String numbers = "10 20 30 40 50";
Scanner scanner = new Scanner(numbers);
while (scanner.hasNext()) {
    if (scanner.hasNextInt()) {
        int number = scanner.nextInt();
        System.out.println("Разобрано: " + number);
    } else {
        scanner.next(); // Пропускаем токены, не являющиеся целыми числами
    }
}

Заключение

Преобразование строки в int в Java является простой задачей с использованием Integer.parseInt() и Integer.valueOf(), но требует правильной обработки ошибок. Ключевые выводы включают:

• Используйте Integer.parseInt() для примитивных значений int и лучшей производительности
• Используйте Integer.valueOf(), когда вам нужен объект Integer
• Всегда обрабатывайте NumberFormatException для недопустимых входных данных
• Рассмотрите предварительную валидацию для пользовательского ввода для предоставления более информативных сообщений об ошибках
• Используйте современные подходы, такие как Optional, для более безопасных шаблонов преобразования
• Будьте осведомлены о различных форматах чисел (шестнадцатеричном, двоичном, восьмеричном)
• Обрабатывайте крайние случаи: null, пустые строки и значения вне диапазона

Для большинства приложений простой метод Integer.parseInt() с соответствующей обработкой исключений обеспечивает наилучший баланс простоты и надежности. Всегда проверяйте входные данные перед преобразованием для обеспечения надежных и удобных для пользователя приложений.

Источники

1. Официальная документация Java - Класс Integer
2. Учебники Oracle Java - Числа и строки
3. Документация Java Integer.parseInt()
4. Документация Java Integer.valueOf()
5. Документация Java NumberFormatException