Как проверить, можно ли преобразовать строку в целое число на Java

Введение

В этом практическом занятии (лабораторной работе) вы научитесь проверять, можно ли преобразовать строку в целое число на Java. Это фундаментальный навык для обработки пользовательского ввода или данных из внешних источников.

Вы изучите метод Integer.parseInt() для попытки преобразования, узнаете, как обрабатывать возможные ошибки с использованием NumberFormatException, и откроете методы валидации строки перед попыткой ее разбора, чтобы обеспечить надежность и отсутствие ошибок в коде.

Попробуйте преобразовать с помощью Integer.parseInt()

На этом этапе мы рассмотрим, как преобразовать String (текст) в int (целое число) на Java. Это распространенная задача в программировании, особенно когда вам нужно получить числовой ввод от пользователя или прочитать числа из файла.

Java предоставляет встроенный метод Integer.parseInt() для этой цели. Давайте посмотрим, как он работает.

Сначала убедитесь, что вы находитесь в директории ~/project. Если необходимо, вы можете использовать команду cd ~/project в терминале.
Теперь создадим новый Java-файл с именем StringToInt.java в директории ~/project. Для этого вы можете кликнуть правой кнопкой мыши в проводнике файлов слева, выбрать "New File" и ввести StringToInt.java.
Откройте файл StringToInt.java в редакторе кода и вставьте следующий код:
```
public class StringToInt {
    public static void main(String[] args) {
        String numberString = "123";
        int numberInt = Integer.parseInt(numberString);

        System.out.println("The string is: " + numberString);
        System.out.println("The integer is: " + numberInt);
    }
}
```
Рассмотрим новые части кода:
- String numberString = "123";: Мы объявляем переменную типа String с именем numberString и присваиваем ей значение "123". Обратите внимание, что "123" заключено в двойные кавычки, что означает, что это строка.
- int numberInt = Integer.parseInt(numberString);: Это основа данного этапа. Мы вызываем метод Integer.parseInt(), передавая в качестве аргумента нашу переменную numberString. Этот метод пытается преобразовать строку "123" в целое число. Результат сохраняется в переменной типа int с именем numberInt.
- System.out.println("The string is: " + numberString);: Эта строка выводит исходную строку.
- System.out.println("The integer is: " + numberInt);: Эта строка выводит преобразованное целое число.
Сохраните файл (Ctrl+S или Cmd+S).
Теперь скомпилируем программу. Откройте терминал и выполните следующую команду:
```
javac StringToInt.java
```
Если компиляция прошла успешно, вы не должны увидеть никакого вывода, и в директории ~/project будет создан файл StringToInt.class.
Наконец, запустите скомпилированную программу:
```
java StringToInt
```
Вы должны увидеть следующий вывод:
```
The string is: 123
The integer is: 123
```
Как вы можете видеть, метод Integer.parseInt() успешно преобразовал строку "123" в целое число 123.

На следующем этапе мы рассмотрим, что происходит, когда строку невозможно преобразовать в целое число.

Перехватить исключение NumberFormatException

На предыдущем этапе мы успешно преобразовали строку, содержащую только цифры, в целое число с помощью Integer.parseInt(). Но что произойдет, если строка содержит символы, не являющиеся цифрами? Давайте узнаем.

Когда метод Integer.parseInt() пытается преобразовать строку, которая не является корректным представлением числа, он выбрасывает исключение NumberFormatException. Это тип ошибки, указывающий на проблему с форматом строки числа.

Для элегантной обработки таких ошибок мы можем использовать блок try-catch. Блок try-catch позволяет нам "попробовать" выполнить фрагмент кода, который может вызвать ошибку, и если ошибка возникает, мы можем "перехватить" ее и обработать ее определенным образом, предотвращая аварийное завершение программы.

Давайте модифицируем нашу программу StringToInt.java, чтобы продемонстрировать это.

Откройте файл StringToInt.java в редакторе WebIDE.
Измените код, добавив блок try-catch и изменив входную строку:
```
public class StringToInt {
    public static void main(String[] args) {
        String numberString = "abc"; // This string cannot be parsed as an integer

        try {
            int numberInt = Integer.parseInt(numberString);
            System.out.println("The string is: " + numberString);
            System.out.println("The integer is: " + numberInt);
        } catch (NumberFormatException e) {
            System.out.println("Error: Could not convert the string to an integer.");
            System.out.println("Details: " + e.getMessage());
        }
    }
}
```
Вот что мы добавили:
- String numberString = "abc";: Мы изменили строку на "abc", которая явно не является корректным целым числом.
- try { ... }: Код внутри блока try - это то, что мы хотим попробовать выполнить. В данном случае это вызов Integer.parseInt().
- catch (NumberFormatException e) { ... }: Если в блоке try возникает исключение NumberFormatException, будет выполнен код внутри блока catch.
- System.out.println("Error: Could not convert the string to an integer.");: Эта строка выводит понятное для пользователя сообщение об ошибке.
- System.out.println("Details: " + e.getMessage());: Эта строка выводит более подробную информацию об исключении, что может быть полезно для отладки.
Сохраните файл (Ctrl+S или Cmd+S).
Скомпилируйте модифицированную программу в терминале:
```
javac StringToInt.java
```
Запустите скомпилированную программу:
```
java StringToInt
```
На этот раз, так как строку "abc" нельзя преобразовать в целое число, исключение NumberFormatException будет перехвачено, и вы должны увидеть вывод, похожий на следующий:
```
Error: Could not convert the string to an integer.
Details: For input string: "abc"
```
Вместо аварийного завершения программы блок catch обработал ошибку и вывел полезное сообщение. Это намного лучше для пользователя!

Использование блоков try-catch является важной частью написания надежных программ, которые могут обрабатывать неожиданный ввод или ситуации.

Валидация строки перед преобразованием

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

На этом этапе мы научимся валидировать строку перед попыткой ее разбора как целого числа. Это включает в себя проверку, содержит ли строка только цифры.

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

Давайте снова модифицируем нашу программу StringToInt.java, чтобы включить проверку валидности.

Откройте файл StringToInt.java в редакторе WebIDE.
Замените существующий код следующим:
```
public class StringToInt {

    public static void main(String[] args) {
        String numberString = "123a"; // This string contains a non-digit character

        if (isValidInteger(numberString)) {
            int numberInt = Integer.parseInt(numberString);
            System.out.println("The string is: " + numberString);
            System.out.println("The integer is: " + numberInt);
        } else {
            System.out.println("Error: The string '" + numberString + "' is not a valid integer.");
        }
    }

    // Method to check if a string is a valid integer
    public static boolean isValidInteger(String str) {
        if (str == null || str.isEmpty()) {
            return false; // An empty or null string is not a valid integer
        }
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            if (i == 0 && (c == '-' || c == '+')) {
                // Allow a leading sign (+ or -)
                continue;
            }
            if (!Character.isDigit(c)) {
                return false; // Found a non-digit character
            }
        }
        return true; // All characters are digits (or a leading sign)
    }
}
```
Рассмотрим изменения:
- Мы добавили новый метод isValidInteger(String str). Этот метод принимает строку в качестве входных данных и возвращает true, если строка представляет собой корректное целое число, и false в противном случае.
- Внутри isValidInteger мы сначала проверяем, является ли строка null или пустой.
- Затем мы проходим по каждому символу строки в цикле.
- Character.isDigit(c) - это встроенный метод Java, который проверяет, является ли символ цифрой.
- Мы добавили проверку, чтобы разрешить ведущий знак плюс или минус.
- В методе main мы теперь используем оператор if-else. Мы вызываем isValidInteger() для проверки строки перед попыткой ее разбора.
- Если isValidInteger() возвращает true, мы продолжаем с вызовом Integer.parseInt().
- Если он возвращает false, мы выводим сообщение об ошибке без попытки разбора, тем самым избавляясь от исключения NumberFormatException.
Сохраните файл (Ctrl+S или Cmd+S).
Скомпилируйте модифицированную программу в терминале:
```
javac StringToInt.java
```
Запустите скомпилированную программу:
```
java StringToInt
```
Поскольку строка "123a" содержит символ, не являющийся цифрой, метод isValidInteger вернет false, и вы должны увидеть следующий вывод:
```
Error: The string '123a' is not a valid integer.
```
Теперь изменим строку обратно на корректное целое число, чтобы увидеть другую ветку оператора if-else.
Измените переменную numberString обратно на "456" в файле StringToInt.java:
```
String numberString = "456";
```
Сохраните файл.
Скомпилируйте и запустите программу снова:
```
javac StringToInt.java
java StringToInt
```
На этот раз метод isValidInteger вернет true, и вы должны увидеть:
```
The string is: 456
The integer is: 456
```

Валидируя строку перед разбором, мы можем более элегантно обрабатывать некорректный ввод и избегать ошибок времени выполнения, таких как NumberFormatException. Это хорошая практика для написания более надежного и устойчивого к ошибкам кода.

Резюме

В этом практическом занятии (лабораторной работе) мы научились преобразовывать String в int на Java с использованием метода Integer.parseInt(). Мы создали файл на Java, написали код для демонстрации этого преобразования и скомпилировали программу. Этот метод является важным инструментом для обработки числовых входных данных из различных источников.