Wie man prüft, ob eine Zahl in Java eine Fließkommazahl (float) ist

Einführung

In diesem Lab werden Sie lernen, wie Sie prüfen können, ob eine Zahl in Java eine Fließkommazahl (float) ist. Wir werden verschiedene Techniken untersuchen, beginnend mit der Überprüfung, ob ein Objekt eine Instanz der Float-Klasse ist.

Anschließend werden Sie lernen, wie Sie einen String in eine Fließkommazahl umwandeln und schließlich, wie Sie Fließkommazahlen (float) mit Gleitkommazahlen (double) vergleichen können, wobei Sie die Feinheiten und potenziellen Fallstricke dieser Operationen verstehen.

Überprüfen der Instanz der Float-Klasse

In diesem Schritt werden wir die Float-Klasse in Java untersuchen und lernen, wie man Instanzen dieser Klasse erstellt und überprüft. In Java haben primitive Datentypen wie float entsprechende Wrapper-Klassen, wie z. B. Float. Diese Wrapper-Klassen bieten nützliche Methoden für die Arbeit mit den primitiven Typen.

Zunächst erstellen wir eine neue Java-Datei namens FloatExample.java in Ihrem ~/project-Verzeichnis. Sie können dies tun, indem Sie mit der rechten Maustaste im Dateiexplorer links klicken und "Neue Datei" auswählen, und dann FloatExample.java eingeben.
Öffnen Sie die FloatExample.java-Datei im Editor und fügen Sie den folgenden Code hinzu:
```
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);
    }
}
```
Lassen Sie uns die neuen Teile dieses Codes analysieren:
- float primitiveFloat = 123.45f;: Diese Zeile deklariert eine primitive float-Variable und weist ihr einen Wert zu. Das f am Ende ist wichtig, um anzuzeigen, dass dies ein float-Literal ist.
- Float objectFloat = new Float(primitiveFloat);: Diese Zeile erstellt ein Float-Objekt mithilfe des Float-Klassenkonsruktors und des primitiven float-Werts.
- boolean isFloatInstance = objectFloat instanceof Float;: Der instanceof-Operator wird verwendet, um zu prüfen, ob ein Objekt eine Instanz einer bestimmten Klasse ist. Hier überprüfen wir, ob objectFloat eine Instanz der Float-Klasse ist. Das Ergebnis wird in einer booleschen Variable isFloatInstance gespeichert.
- System.out.println("Is objectFloat an instance of Float? " + isFloatInstance);: Diese Zeile gibt das Ergebnis der Überprüfung in der Konsole aus.
Speichern Sie die FloatExample.java-Datei (Strg+S oder Cmd+S).
Jetzt kompilieren wir das Programm. Öffnen Sie das Terminal unten im WebIDE und stellen Sie sicher, dass Sie sich im ~/project-Verzeichnis befinden. Führen Sie dann den folgenden Befehl aus:
```
javac FloatExample.java
```
Wenn die Kompilierung erfolgreich ist, sollten Sie keine Ausgabe sehen, und es wird eine FloatExample.class-Datei im ~/project-Verzeichnis erstellt.
Führen Sie schließlich das kompilierte Programm mit dem java-Befehl aus:
```
java FloatExample
```
Sie sollten die folgende Ausgabe sehen:
```
Is objectFloat an instance of Float? true
```
Diese Ausgabe bestätigt, dass das von uns erstellte objectFloat tatsächlich eine Instanz der Float-Klasse ist. Das Verständnis des Unterschieds zwischen primitiven Typen und ihren Wrapper-Klassen ist in Java wichtig.

Zeichenkette in Fließkommazahl (float) umwandeln

In diesem Schritt werden Sie lernen, wie Sie in Java eine String-Darstellung einer Zahl in einen float-Wert umwandeln können. Dies ist eine häufige Aufgabe, wenn Sie numerische Eingaben als Text erhalten, beispielsweise von Benutzereingaben oder beim Lesen aus einer Datei. Die Float-Wrapper-Klasse bietet eine bequeme Methode für diese Umwandlung.

Öffnen Sie erneut die FloatExample.java-Datei im Editor.
Ersetzen Sie den vorhandenen Code durch den folgenden neuen Code:
```
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);
    }
}
```
Schauen wir uns die neuen Teile an:
- String floatString = "987.65";: Wir definieren eine String-Variable, die die Textrepräsentation einer Fließkommazahl enthält.
- float parsedFloatPrimitive = Float.parseFloat(floatString);: Die Methode Float.parseFloat() ist eine statische Methode der Float-Klasse, die einen String als Eingabe nimmt und einen primitiven float-Wert zurückgibt.
- Float parsedFloatObject = Float.valueOf(floatString);: Die Methode Float.valueOf() ist eine weitere statische Methode, die ebenfalls einen String nimmt und ein Float-Objekt zurückgibt. Beide Methoden erreichen die Umwandlung, aber die eine gibt einen primitiven Wert und die andere ein Objekt zurück.
Speichern Sie die FloatExample.java-Datei (Strg+S oder Cmd+S).
Kompilieren Sie das geänderte Programm im Terminal:
```
javac FloatExample.java
```
Wiederum wird bei Erfolg keine Ausgabe angezeigt.
Führen Sie das kompilierte Programm aus:
```
java FloatExample
```
Sie sollten die folgende Ausgabe sehen:
```
Parsed primitive float: 987.65
Parsed Float object: 987.65
```
Dies zeigt, wie Sie erfolgreich eine Zeichenkette, die eine gültige Fließkommazahl enthält, sowohl in einen primitiven float-Wert als auch in ein Float-Objekt umwandeln können, indem Sie die Methoden der Float-Klasse verwenden.

Hinweis: Wenn die Zeichenkette keine gültige Fließkommazahl enthält, werfen diese Methoden eine NumberFormatException. Es ist wichtig, solche Ausnahmen in realen Anwendungen zu behandeln, aber für dieses einfache Beispiel gehen wir davon aus, dass die Eingabezeichenkette gültig ist.

Float-Wert mit Double-Wert vergleichen

In diesem Schritt werden wir untersuchen, wie man float- und double-Werte in Java vergleicht. Sowohl float als auch double werden zur Darstellung von Fließkommazahlen verwendet, aber double bietet eine höhere Genauigkeit als float. Das Vergleichen von Fließkommazahlen kann manchmal schwierig sein, aufgrund möglicher Genauigkeitsunterschiede.

Öffnen Sie die FloatExample.java-Datei im Editor ein letztes Mal.

Ersetzen Sie den vorhandenen Code durch den folgenden Code, der das Vergleichen von float und double demonstriert:

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);
    }
}

Schauen wir uns den neuen Code an:

float floatValue = 0.1f;: Wir definieren eine float-Variable mit dem Wert 0,1.
double doubleValue = 0.1;: Wir definieren eine double-Variable mit dem Wert 0,1.
boolean areEqualUsingEquals = (floatValue == doubleValue);: Wir verwenden den Gleichheitsoperator ==, um die float- und double-Werte direkt zu vergleichen.
boolean areEqualUsingCast = (floatValue == (float) doubleValue);: Wir wandeln den doubleValue in einen float um, bevor wir vergleichen. Dies kann manchmal zu unerwarteten Ergebnissen führen, aufgrund von Genauigkeitsverlusten.
double tolerance = 0.000001;: Wir definieren einen kleinen Wert namens Toleranz.
boolean areEqualWithTolerance = Math.abs(floatValue - doubleValue) < tolerance;: Ein robusterer Weg, Fließkommazahlen zu vergleichen, besteht darin, zu prüfen, ob die absolute Differenz zwischen ihnen kleiner als eine sehr kleine Zahl (die Toleranz) ist. Math.abs() berechnet den absoluten Wert.

Speichern Sie die FloatExample.java-Datei (Strg+S oder Cmd+S).
Kompilieren Sie das Programm im Terminal:
```
javac FloatExample.java
```
Führen Sie das kompilierte Programm aus:
```
java FloatExample
```
Sie sollten eine Ausgabe ähnlich der folgenden sehen:
```
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
```
Beachten Sie, dass das direkte Vergleichen von floatValue und doubleValue mit == false ergibt. Dies liegt daran, dass 0,1 in binärer Fließkommadarstellung nicht exakt dargestellt werden kann, und die float- und double-Darstellungen von 0,1 geringfügig unterschiedlich sind. Das Umwandeln des double in float vor dem Vergleich kann in einigen Fällen dazu führen, dass sie gleich erscheinen, aber der zuverlässigste Weg, Fließkommazahlen auf praktische Gleichheit zu vergleichen, besteht darin, zu prüfen, ob ihre Differenz innerhalb einer kleinen Toleranz liegt.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man in Java prüft, ob eine Zahl eine Fließkommazahl (float) ist. Wir haben zunächst die Float-Wrapper-Klasse untersucht und wie man Instanzen dieser Klasse erstellt und überprüft, indem man den instanceof-Operator verwendet. Dies beinhaltete das Erstellen einer primitiven float-Variable und das Umwickeln (wrapping) dieser in ein Float-Objekt, um das Konzept der Wrapper-Klassen und ihre Beziehung zu primitiven Datentypen zu demonstrieren.

Anschließend haben wir uns damit beschäftigt, eine Zeichenkettenrepräsentation einer Zahl in einen Float-Wert zu parsen, indem wir die Methode Float.parseFloat() verwendeten. Dieser Schritt hat gezeigt, wie man Zeichenketteneingaben verarbeitet und in numerische Datentypen umwandelt, was in der Programmierung eine häufige Aufgabe ist. Schließlich haben wir die Feinheiten beim Vergleich von Float-Werten mit Double-Werten untersucht, wobei wir die möglichen Genauigkeitsunterschiede verstanden haben und die Wichtigkeit des Einsatzes geeigneter Vergleichsmethoden oder die Berücksichtigung einer Toleranz bei Gleichheitsüberprüfungen erkannt haben.