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

Введение

В этом лабораторном занятии (LabEx) вы научитесь проверять, является ли число числом с плавающей точкой (float) в Java. Мы рассмотрим различные методы, начиная с проверки, является ли объект экземпляром класса Float.

Затем вы узнаете, как преобразовать строку в число с плавающей точкой (float), и, наконец, как сравнивать значения с плавающей точкой (float) с значениями двойной точности (double), поняв нюансы и возможные подводные камни, связанные с этими операциями.

Проверка экземпляра класса Float

На этом этапе мы рассмотрим класс Float в Java и узнаем, как создавать и проверять экземпляры этого класса. В Java примитивные типы данных, такие как float, имеют соответствующие классы-обертки, например, Float. Эти классы-обертки предоставляют полезные методы для работы с примитивными типами.

Сначала создадим новый Java-файл с именем FloatExample.java в директории ~/project. Для этого можно щелкнуть правой кнопкой мыши в проводнике файлов слева и выбрать "New File", а затем ввести FloatExample.java.
Откройте файл FloatExample.java в редакторе и добавьте следующий код:
```
public class FloatExample {
    public static void main(String[] args) {
        // Create a primitive float variable
        float primitiveFloat = 123.45f;

        // Create a Float object using the constructor
        Float objectFloat = new Float(primitiveFloat);

        // Verify if objectFloat is an instance of the Float class
        boolean isFloatInstance = objectFloat instanceof Float;

        // Print the result
        System.out.println("Is objectFloat an instance of Float? " + isFloatInstance);
    }
}
```
Разберем новые части этого кода:
- float primitiveFloat = 123.45f;: Эта строка объявляет примитивную переменную типа float и присваивает ей значение. Символ f в конце важен, чтобы указать, что это литерал типа float.
- Float objectFloat = new Float(primitiveFloat);: Эта строка создает объект класса Float с использованием конструктора класса Float и примитивного значения типа float.
- boolean isFloatInstance = objectFloat instanceof Float;: Оператор instanceof используется для проверки, является ли объект экземпляром определенного класса. Здесь мы проверяем, является ли objectFloat экземпляром класса Float. Результат сохраняется в булевой переменной isFloatInstance.
- System.out.println("Is objectFloat an instance of Float? " + isFloatInstance);: Эта строка выводит результат проверки в консоль.
Сохраните файл FloatExample.java (Ctrl+S или Cmd+S).
Теперь скомпилируем программу. Откройте терминал внизу WebIDE и убедитесь, что вы находитесь в директории ~/project. Затем выполните следующую команду:
```
javac FloatExample.java
```
Если компиляция прошла успешно, вы не должны увидеть никакого вывода, и в директории ~/project будет создан файл FloatExample.class.
Наконец, запустите скомпилированную программу с помощью команды java:
```
java FloatExample
```
Вы должны увидеть следующий вывод:
```
Is objectFloat an instance of Float? true
```
Этот вывод подтверждает, что созданный нами объект objectFloat действительно является экземпляром класса Float. Понимание различий между примитивными типами и их классами-обертками имеет важное значение в Java.

Преобразование строки в тип float

На этом этапе мы научимся преобразовывать строковое представление числа в значение типа float в Java. Это распространенная задача, когда числовой ввод получается в виде текста, например, от пользователя или при чтении из файла. Класс-обертка Float предоставляет удобный метод для такого преобразования.

Откройте снова файл FloatExample.java в редакторе.
Замените существующий код следующим новым кодом:
```
public class FloatExample {
    public static void main(String[] args) {
        // Define a string containing a float value
        String floatString = "987.65";

        // Parse the string to a float primitive
        float parsedFloatPrimitive = Float.parseFloat(floatString);

        // Parse the string to a Float object
        Float parsedFloatObject = Float.valueOf(floatString);

        // Print the results
        System.out.println("Parsed primitive float: " + parsedFloatPrimitive);
        System.out.println("Parsed Float object: " + parsedFloatObject);
    }
}
```
Рассмотрим новые части кода:
- String floatString = "987.65";: Мы определяем переменную типа String, которая содержит текстовое представление числа с плавающей точкой.
- float parsedFloatPrimitive = Float.parseFloat(floatString);: Метод Float.parseFloat() - это статический метод класса Float, который принимает строку в качестве входных данных и возвращает примитивное значение типа float.
- Float parsedFloatObject = Float.valueOf(floatString);: Метод Float.valueOf() - это еще один статический метод, который также принимает строку и возвращает объект типа Float. Оба метода выполняют преобразование, но один возвращает примитив, а другой - объект.
Сохраните файл FloatExample.java (Ctrl+S или Cmd+S).
Скомпилируйте модифицированную программу в терминале:
```
javac FloatExample.java
```
Опять же, если компиляция прошла успешно, не будет никакого вывода.
Запустите скомпилированную программу:
```
java FloatExample
```
Вы должны увидеть следующий вывод:
```
Parsed primitive float: 987.65
Parsed Float object: 987.65
```
Это показывает, как можно успешно преобразовать строку, содержащую допустимое число с плавающей точкой, как в примитивный тип float, так и в объект типа Float с использованием методов класса Float.

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

Сравнение значений типа float и double

На этом этапе мы рассмотрим, как сравнивать значения типов float и double в Java. И float, и double используются для представления чисел с плавающей точкой, но double обеспечивает большую точность, чем float. Сравнение чисел с плавающей точкой может быть сложным из-за возможных различий в точности.

Откройте файл FloatExample.java в редакторе в последний раз.

Замените существующий код следующим кодом, который демонстрирует сравнение значений float и double:

public class FloatExample {
    public static void main(String[] args) {
        // Define a float value
        float floatValue = 0.1f;

        // Define a double value
        double doubleValue = 0.1;

        // Compare using the equality operator (==)
        boolean areEqualUsingEquals = (floatValue == doubleValue);

        // Compare using the compareTo method (for Float objects)
        // First, convert primitive float to Float object
        Float floatObject = floatValue;
        // Convert primitive double to Double object (for comparison with Float object)
        Double doubleObject = doubleValue;

        // Note: Direct compareTo between Float and Double objects is not standard.
        // We usually compare their primitive values or convert one to the other type.
        // Let's compare the primitive values after casting the double to float.
        boolean areEqualUsingCast = (floatValue == (float) doubleValue);


        // Print the results
        System.out.println("Float value: " + floatValue);
        System.out.println("Double value: " + doubleValue);
        System.out.println("Are they equal using ==? " + areEqualUsingEquals);
        System.out.println("Are they equal after casting double to float? " + areEqualUsingCast);

        // A safer way to compare floating-point numbers is to check if the absolute difference is within a small tolerance.
        double tolerance = 0.000001; // Define a small tolerance
        boolean areEqualWithTolerance = Math.abs(floatValue - doubleValue) < tolerance;
        System.out.println("Are they equal within tolerance? " + areEqualWithTolerance);
    }
}

Рассмотрим новый код:

float floatValue = 0.1f;: Мы определяем переменную типа float со значением 0.1.
double doubleValue = 0.1;: Мы определяем переменную типа double со значением 0.1.
boolean areEqualUsingEquals = (floatValue == doubleValue);: Мы используем оператор равенства == для прямого сравнения значений float и double.
boolean areEqualUsingCast = (floatValue == (float) doubleValue);: Мы преобразуем doubleValue в тип float перед сравнением. Это может привести к неожиданным результатам из-за потери точности.
double tolerance = 0.000001;: Мы определяем небольшое значение, называемое допуском (tolerance).
boolean areEqualWithTolerance = Math.abs(floatValue - doubleValue) < tolerance;: Более надежный способ сравнения чисел с плавающей точкой - проверить, меньше ли абсолютная разность между ними, чем очень маленькое число (допуск). Math.abs() вычисляет абсолютное значение.

Сохраните файл FloatExample.java (Ctrl+S или Cmd+S).
Скомпилируйте программу в терминале:
```
javac FloatExample.java
```
Запустите скомпилированную программу:
```
java FloatExample
```
Вы должны увидеть вывод, похожий на следующий:
```
Float value: 0.1
Double value: 0.1
Are they equal using ==? false
Are they equal after casting double to float? true
Are they equal within tolerance? true
```
Обратите внимание, что прямое сравнение floatValue и doubleValue с использованием == дает результат false. Это происходит потому, что число 0.1 не может быть представлено точно в двоичном формате с плавающей точкой, и представления 0.1 в форматах float и double несколько различаются. Преобразование double в float перед сравнением может сделать их равными в некоторых случаях, но наиболее надежный способ сравнения чисел с плавающей точкой для практического равенства - проверить, находится ли разность между ними в пределах небольшого допуска.

Резюме

В этом практическом занятии (lab) мы научились проверять, является ли число значением типа float в Java. Мы начали с изучения класса-обертки Float и способа создания и проверки экземпляров этого класса с использованием оператора instanceof. Это включало создание примитивного значения типа float и его оборачивание в объект типа Float для демонстрации концепции классов-оберток и их связи с примитивными типами.

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