Как преобразовать строку в int в Java?

Есть два способа выполнить преобразование строки в целое число:

Integer x = Integer.valueOf(str);
// или
int y = Integer.parseInt(str);

Между этими методами есть небольшая разница:

• valueOf возвращает новый объект или кэшированный экземпляр java.lang.Integer.
• parseInt возвращает примитивный тип int.

Такая же ситуация наблюдается для других типов: Short.valueOf/parseShort, Long.valueOf/parseLong и т.д.

Чтобы вручную перевести строку в целое число, можно использовать следующий метод на языке Java:

public static int strToInt(String str) {
    int i = 0; // Индекс для обхода строки
    int num = 0; // Переменная для хранения конечного результата
    boolean isNeg = false; // Флаг для определения отрицательного числа

    // Проверяем, есть ли знак минус в начале строки; если да, устанавливаем флаг isNeg
    if (str.charAt(0) == '-') {
        isNeg = true;
        i = 1; // Начинаем с первого символа после знака
    }

    // Обрабатываем каждый символ строки
    while (i < str.length()) {
        num *= 10; // Умножаем текущее число на 10 для сдвига влево
        num += str.charAt(i++) - '0'; // Вычитаем ASCII-код '0', чтобы преобразовать символ в соответствующее целое значение
    }

    // Если число отрицательное, меняем знак
    if (isNeg)
        num = -num;

    return num; // Возвращаем полученное целое число
}

Этот метод сначала проверяет, является ли строка отрицательной. Затем он проходит по каждому символу строки, умножает текущее значение num на 10 и добавляет к нему числовое значение текущего символа, полученное вычитанием ASCII-кода '0'. В конце, если строка была отрицательной, мы инвертируем знак числа и возвращаем результат.

В данный момент я выполняю задание для колледжа, где нельзя использовать определенные выражения, такие как те, что приведены выше. Посмотрев на ASCII-таблицу, я смог это сделать. Код получился гораздо более сложным, но он может помочь другим, кто столкнулся с аналогичными ограничениями, как и я.

Первое, что нужно сделать, это получить вводимые данные, в данном случае строку цифр; я назову ее String number, и для примера возьму число 12, следовательно, String number = "12";.

Еще одним ограничением было то, что я не мог использовать циклы, поэтому цикл for (который был бы идеален) также не подходит. Это немного ограничивает нас, но тем не менее, это и есть цель задания. Поскольку мне нужны только две цифры (в данном случае последние две), то простого вызова charAt будет достаточно:

// Получаем целочисленные значения символов '1' и '2' в ASCII
int semilastdigitASCII = number.charAt(number.length() - 2);
int lastdigitASCII = number.charAt(number.length() - 1);

После получения кодов нам остается лишь обратиться к таблице ASCII и сделать необходимые преобразования:

double semilastdigit = semilastdigitASCII - 48;  // Быстрый взгляд, и -48 - это ключ
double lastdigit = lastdigitASCII - 48;

Теперь почему двойные числа? Дело в очень "странном" шаге. На данный момент у нас есть два двойных числа, 1 и 2, но нам нужно превратить это в 12, мы не можем выполнить никакие математические операции.

Мы делим последнее число (lastdigit) на 10 подобным образом: 2/10 = 0.2 (поэтому используем тип double):

lastdigit = lastdigit / 10;

Это лишь игра с числами. Мы превращаем последнюю цифру в десятичное число. Но теперь посмотрите, что происходит:

double jointdigits = semilastdigit + lastdigit; // 1.0 + 0.2 = 1.2

Не углубляясь в математику, мы просто изолируем единицы цифр числа. Видите, поскольку мы рассматриваем только цифры от 0 до 9, деление на 10 создает "коробочку", куда мы это помещаем (вспомните, как ваша учительница в первом классе объясняла, что такое единицы и сотни). Итак:

int finalnumber = (int) (jointdigits * 10); // Не забудьте использовать скобки "()"

И вот, мы превратили строку цифр (в данном случае, состоящую из двух цифр) в целое число, составленное из этих двух цифр, учитывая следующие ограничения:

• Без повторяющихся циклов
• Без "волшебных" выражений, таких как parseInt

Когда существует минимальная вероятность того, что заданная строка не содержит целое число, необходимо обработать этот специальный случай. К сожалению, стандартные методы Java Integer::parseInt и Integer::valueOf выбрасывают исключение NumberFormatException, чтобы сигнализировать о такой ситуации. Таким образом, вам придется использовать исключения для управления потоком, что обычно считается плохим стилем кода.

На мой взгляд, этот специальный случай следует обрабатывать, возвращая пустой Optional<Integer>. Поскольку Java не предоставляет такого метода, я использую следующий обёртку:

private Optional<Integer> tryParseInteger(String string) {
    try {
        return Optional.of(Integer.valueOf(string));
    } catch (NumberFormatException e) {
        return Optional.empty();
    }
}

Пример использования:

// выводит "12"
System.out.println(tryParseInteger("12").map(i -> i.toString()).orElse("invalid"));
// выводит "-1"
System.out.println(tryParseInteger("-1").map(i -> i.toString()).orElse("invalid"));
// выводит "invalid"
System.out.println(tryParseInteger("ab").map(i -> i.toString()).orElse("invalid"));

Хотя это все еще использует исключения для управления потоком внутри метода, код на выходе становится очень чистым. Кроме того, вы можете четко различать случай, когда -1 обработан как допустимое значение, и случай, когда недопустимая строка не может быть обработана.

Вы также можете начать с удаления всех нечисловых символов, а затем преобразовать строку в целое число:

String mystr = mystr.replaceAll("[^\\d]", "");
int number = Integer.parseInt(mystr);

Однако учтите, что этот подход работает только для неотрицательных чисел.