如何在 Java 中检查一个数字是否为浮点数

简介

在这个实验中，你将学习如何在 Java 中检查一个数字是否为浮点数。我们将探索不同的技术，首先是验证一个对象是否为 Float 类的实例。

然后，你将学习如何将字符串解析为浮点数，最后，学习如何比较浮点数和双精度数，了解这些操作中的细微差别和潜在陷阱。

Skills Graph

验证 Float 类的实例

在这一步中，我们将探索 Java 中的 Float 类，以及如何创建和验证该类的实例。在 Java 中，像 float 这样的基本数据类型都有对应的包装类，比如 Float。这些包装类为处理基本数据类型提供了有用的方法。

1. 首先，在你的 ~/project 目录下创建一个名为 FloatExample.java 的新 Java 文件。你可以通过在左侧的文件资源管理器中右键单击，选择“新建文件”，然后输入 FloatExample.java 来完成。

2. 在编辑器中打开 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 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);：这行代码将检查结果打印到控制台。

3. 保存 FloatExample.java 文件（Ctrl + S 或 Cmd + S）。

4. 现在，让我们来编译这个程序。打开 WebIDE 底部的终端，并确保你位于 ~/project 目录下。然后，运行以下命令：

   javac FloatExample.java

   如果编译成功，你应该看不到任何输出，并且 ~/project 目录下会创建一个 FloatExample.class 文件。

5. 最后，使用 java 命令运行编译后的程序：

   java FloatExample

   你应该会看到以下输出：

   Is objectFloat an instance of Float? true

   这个输出确认了我们创建的 objectFloat 确实是 Float 类的实例。理解基本数据类型与其包装类之间的区别在 Java 中非常重要。

将字符串解析为浮点数

在这一步中，你将学习如何在 Java 中将数字的 String 表示形式转换为 float 值。当你以文本形式接收数值输入时，例如从用户输入或从文件中读取，这是一项常见的任务。Float 包装类为此转换提供了便捷的方法。

1. 再次在编辑器中打开 FloatExample.java 文件。

2. 将现有代码替换为以下新代码：

   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 类的静态方法，它接受一个 String 作为输入，并返回一个基本的 float 值。
   • Float parsedFloatObject = Float.valueOf(floatString);：Float.valueOf() 方法是另一个静态方法，它同样接受一个 String 并返回一个 Float 对象。这两种方法都能实现转换，但一个返回基本类型，另一个返回对象。

3. 保存 FloatExample.java 文件（Ctrl + S 或 Cmd + S）。

4. 在终端中编译修改后的程序：

   javac FloatExample.java

   同样，如果编译成功，将不会有输出。

5. 运行编译后的程序：

   java FloatExample

   你应该会看到以下输出：

   Parsed primitive float: 987.65
   Parsed Float object: 987.65

   这展示了你如何使用 Float 类的方法，成功地将包含有效浮点数的字符串转换为基本的 float 类型和 Float 对象。

   注意： 如果字符串不包含有效的浮点数，这些方法将抛出 NumberFormatException。在实际应用中，处理此类异常非常重要，但在这个基础示例中，我们假设输入的字符串是有效的。

比较浮点数（float）和双精度浮点数（double）

在这一步中，我们将探讨如何在 Java 中比较 float 和 double 值。float 和 double 都用于表示浮点数，但 double 比 float 提供更高的精度。由于潜在的精度差异，比较浮点数有时可能会比较棘手。

1. 最后一次在编辑器中打开 FloatExample.java 文件。

2. 将现有代码替换为以下演示如何比较 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;：定义一个值为 0.1 的 float 变量。
   • double doubleValue = 0.1;：定义一个值为 0.1 的 double 变量。
   • 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() 用于计算绝对值。

3. 保存 FloatExample.java 文件（Ctrl + S 或 Cmd + S）。

4. 在终端中编译程序：

   javac FloatExample.java

5. 运行编译后的程序：

   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 无法用二进制浮点数精确表示，float 和 double 对 0.1 的表示略有不同。在比较之前将 double 强制转换为 float 在某些情况下可能会使它们看起来相等，但在实际应用中，比较浮点数是否相等最可靠的方法是检查它们的差值是否在一个小的容差范围内。

总结

在本次实验中，你学习了如何在 Java 中检查一个数字是否为浮点数。首先，你探索了 Float 包装类，以及如何使用 instanceof 运算符创建和验证该类的实例。这包括创建一个基本的 float 类型，然后将其包装在 Float 对象中，以此展示包装类的概念以及它们与基本类型的关系。

接着，你学习了如何使用 Float.parseFloat() 方法将数字的字符串表示形式解析为 Float 类型。这一步强调了如何处理字符串输入并将其转换为数值类型，这是编程中的常见任务。最后，你研究了比较 Float 值和 Double 值的细微差别，了解了可能存在的精度差异，以及使用适当的比较方法或在进行相等性检查时考虑容差的重要性。