Как проверить, является ли строка числом на Java

Введение

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

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

Skills Graph

Попытка преобразования строки в целое число

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

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

1. Откройте файл HelloJava.java в редакторе WebIDE, если он еще не открыт.

2. Замените все содержимое файла следующим кодом:

   public class HelloJava {
       public static void main(String[] args) {
           String numberString = "123";
           int number = Integer.parseInt(numberString);
           System.out.println("Successfully parsed: " + number);
   
           String invalidString = "abc";
           try {
               int invalidNumber = Integer.parseInt(invalidString);
               System.out.println("This line will not be reached.");
           } catch (NumberFormatException e) {
               System.out.println("Error: Could not parse '" + invalidString + "' to an integer.");
               System.out.println("Exception details: " + e.getMessage());
           }
       }
   }

   Рассмотрим новые части этого кода:

   • String numberString = "123";: Мы создаем строковую переменную numberString и присваиваем ей значение "123".
   • int number = Integer.parseInt(numberString);: Это ядро преобразования. Integer.parseInt() пытается преобразовать строку "123" в целое число. Поскольку "123" является допустимым представлением целого числа, это преобразование выполнится успешно, и целочисленное значение 123 будет сохранено в переменной number.
   • String invalidString = "abc";: Мы создаем еще одну строковую переменную invalidString и присваиваем ей значение "abc". Эта строка не представляет собой допустимое целое число.
   • try { ... } catch (NumberFormatException e) { ... }: Это блок try-catch, который используется для обработки ошибок (исключений) в Java.
     • Код внутри блока try - это место, где мы помещаем операцию, которая может вызвать ошибку. В данном случае это Integer.parseInt(invalidString).
     • Если Integer.parseInt("abc") завершается неудачно, потому что "abc" не является допустимым числом, то будет "выброшено" исключение NumberFormatException.
     • Блок catch (NumberFormatException e) "ловит" это конкретное исключение. Затем будет выполнен код внутри блока catch.
   • System.out.println("Error: Could not parse '" + invalidString + "' to an integer.");: Эта строка будет выведена, если произошло исключение NumberFormatException.
   • System.out.println("Exception details: " + e.getMessage());: Это выводит более конкретное сообщение об ошибке, предоставленное объектом исключения e.

3. Сохраните файл (Ctrl+S или Cmd+S).

4. Скомпилируйте программу в терминале:

   javac HelloJava.java

   Если нет ошибок, вы не увидите никакого вывода.

5. Запустите скомпилированную программу:

   java HelloJava

   Вы должны увидеть вывод, похожий на следующий:

   Successfully parsed: 123
   Error: Could not parse 'abc' to an integer.
   Exception details: For input string: "abc"

   Этот вывод показывает, что первая попытка преобразования прошла успешно, но вторая попытка с недопустимой строкой "abc" привела к возникновению исключения NumberFormatException, и наш блок catch элегантно обработал это, выведя сообщение об ошибке.

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

Использование регулярных выражений для проверки на число

На предыдущем этапе мы увидели, что метод Integer.parseInt() выбрасывает исключение, если строка не является допустимым целым числом. Хотя блок try-catch полезен для обработки ошибки, когда она возникает, иногда вы можете захотеть проверить, можно ли преобразовать строку в число до попытки преобразования. Именно здесь регулярные выражения (Regular Expressions, Regex) становятся полезными.

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

1. Откройте файл HelloJava.java в редакторе WebIDE.

2. Замените все содержимое файла следующим кодом:

   public class HelloJava {
       public static void main(String[] args) {
           String numberString = "123";
           String invalidString = "abc";
           String mixedString = "123a";
   
           System.out.println("Checking string: \"" + numberString + "\"");
           if (numberString.matches("\\d+")) {
               System.out.println("  Matches the pattern (contains only digits).");
               int number = Integer.parseInt(numberString);
               System.out.println("  Parsed integer: " + number);
           } else {
               System.out.println("  Does not match the pattern.");
           }
   
           System.out.println("\nChecking string: \"" + invalidString + "\"");
           if (invalidString.matches("\\d+")) {
               System.out.println("  Matches the pattern (contains only digits).");
           } else {
               System.out.println("  Does not match the pattern.");
           }
   
           System.out.println("\nChecking string: \"" + mixedString + "\"");
           if (mixedString.matches("\\d+")) {
               System.out.println("  Matches the pattern (contains only digits).");
           } else {
               System.out.println("  Does not match the pattern.");
           }
       }
   }

   Разберем новые части кода:

   • numberString.matches("\\d+"): Это ключевая часть. Метод matches() доступен для всех объектов типа String в Java. Он проверяет, соответствует ли вся строка заданному шаблону регулярного выражения.
   • "\\d+": Это шаблон регулярного выражения.
     • \\d: Это соответствует любой цифре (от 0 до 9). Мы используем \\, потому что \ - это специальный символ в строках Java, поэтому его нужно экранировать.
     • +: Это квантификатор, который означает "один или более" предыдущего элемента. Таким образом, \\d+ означает "одна или более цифр".
   • Условный оператор if проверяет результат метода matches(). Если он возвращает true, это означает, что строка состоит полностью из одной или более цифр. Если он возвращает false, это означает, что строка содержит символы, отличные от цифр, или является пустой.

3. Сохраните файл (Ctrl+S или Cmd+S).

4. Скомпилируйте программу в терминале:

   javac HelloJava.java

   Если компиляция прошла успешно, вы не должны увидеть никакого вывода.

5. Запустите скомпилированную программу:

   java HelloJava

   Вы должны увидеть вывод, похожий на следующий:

   Checking string: "123"
     Matches the pattern (contains only digits).
     Parsed integer: 123
   
   Checking string: "abc"
     Does not match the pattern.
   
   Checking string: "123a"
     Does not match the pattern.

   Как вы можете видеть, проверка matches("\\d+") правильно определила, что строка "123" состоит только из цифр, в то время как строки "abc" и "123a" не соответствуют шаблону. Этот подход позволяет вам проверить формат строки перед попыткой ее преобразования, что в некоторых случаях может избежать возникновения исключения NumberFormatException.

Обработка отрицательных и десятичных чисел

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

Java предоставляет разные методы для преобразования разных типов чисел:

• Integer.parseInt(): Для целых чисел (integers).
• Double.parseDouble(): Для чисел с десятичной точкой (чисел с плавающей точкой, floating-point numbers).

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

1. Откройте файл HelloJava.java в редакторе WebIDE.

2. Замените все содержимое файла следующим кодом:

   public class HelloJava {
       public static void main(String[] args) {
           String positiveIntString = "456";
           String negativeIntString = "-789";
           String decimalString = "123.45";
           String invalidString = "not a number";
   
           // Handling Integers (positive and negative)
           System.out.println("Attempting to parse integers:");
           try {
               int positiveInt = Integer.parseInt(positiveIntString);
               System.out.println("  Parsed '" + positiveIntString + "' as integer: " + positiveInt);
           } catch (NumberFormatException e) {
               System.out.println("  Could not parse '" + positiveIntString + "' as integer.");
           }
   
           try {
               int negativeInt = Integer.parseInt(negativeIntString);
               System.out.println("  Parsed '" + negativeIntString + "' as integer: " + negativeInt);
           } catch (NumberFormatException e) {
               System.out.println("  Could not parse '" + negativeIntString + "' as integer.");
           }
   
           try {
               int decimalAsInt = Integer.parseInt(decimalString);
               System.out.println("  Parsed '" + decimalString + "' as integer: " + decimalAsInt);
           } catch (NumberFormatException e) {
               System.out.println("  Could not parse '" + decimalString + "' as integer.");
           }
   
           // Handling Decimal Numbers
           System.out.println("\nAttempting to parse decimal numbers:");
           try {
               double decimal = Double.parseDouble(decimalString);
               System.out.println("  Parsed '" + decimalString + "' as double: " + decimal);
           } catch (NumberFormatException e) {
               System.out.println("  Could not parse '" + decimalString + "' as double.");
           }
   
           try {
               double intAsDouble = Double.parseDouble(positiveIntString);
               System.out.println("  Parsed '" + positiveIntString + "' as double: " + intAsDouble);
           } catch (NumberFormatException e) {
               System.out.println("  Could not parse '" + positiveIntString + "' as double.");
           }
   
            try {
               double invalidAsDouble = Double.parseDouble(invalidString);
               System.out.println("  Parsed '" + invalidString + "' as double: " + invalidAsDouble);
           } catch (NumberFormatException e) {
               System.out.println("  Could not parse '" + invalidString + "' as double.");
           }
       }
   }

   Вот что происходит в этом коде:

   • Теперь у нас есть строки, представляющие положительное целое число, отрицательное целое число, десятичное число и недопустимую строку.
   • Мы используем Integer.parseInt() внутри блоков try-catch, чтобы попытаться преобразовать строки в целые числа. Обратите внимание, что Integer.parseInt() может обработать знак минус (-). Однако он выбросит исключение NumberFormatException, если строка содержит десятичную точку или нецифровые символы.
   • Мы используем Double.parseDouble() внутри блоков try-catch, чтобы попытаться преобразовать строки в десятичные числа (тип double). Double.parseDouble() может обработать как целые числа, так и числа с десятичной точкой. Он выбросит исключение NumberFormatException для строк, которые не являются допустимым представлением числа типа double.

3. Сохраните файл (Ctrl+S или Cmd+S).

4. Скомпилируйте программу в терминале:

   javac HelloJava.java

   Если компиляция прошла успешно, вы не должны увидеть никакого вывода.

5. Запустите скомпилированную программу:

   java HelloJava

   Вы должны увидеть вывод, похожий на следующий:

   Attempting to parse integers:
     Parsed '456' as integer: 456
     Parsed '-789' as integer: -789
     Could not parse '123.45' as integer.
   
   Attempting to parse decimal numbers:
     Parsed '123.45' as double: 123.45
     Parsed '456' as double: 456.0
     Could not parse 'not a number' as double.

   Этот вывод показывает, что Integer.parseInt() правильно преобразовал положительное и отрицательное целые числа, но не смог преобразовать строку с десятичным числом. Double.parseDouble() успешно преобразовал как строку с десятичным числом, так и строку с целым числом (представив его как число типа double, например, 456.0), но не смог преобразовать недопустимую строку.

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

Резюме

В этом практическом занятии (lab) мы научились проверять, является ли строка числом на Java. Сначала мы изучили использование метода Integer.parseInt() для попытки преобразования строки в целое число, и поняли, что этот метод выбрасывает исключение NumberFormatException, если строка не является допустимым представлением целого числа. Мы увидели, как обработать это исключение с помощью блока try-catch, чтобы корректно управлять нечисловыми строками.

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