Wie man prüft, ob eine Zahl in Java ein Long ist

Einführung

In diesem Lab werden wir verschiedene Methoden untersuchen, um festzustellen, ob eine Zahl in Java vom Typ Long ist. Wir beginnen damit, zu lernen, wie man den instanceof-Operator verwendet, um zu prüfen, ob ein Objekt eine Instanz der Long-Wrapper-Klasse ist.

Danach werden wir uns mit der Umwandlung von Strings in Long-Werte befassen und verstehen, wie man potenzielle Fehler während dieses Prozesses behandelt. Abschließend werden wir zwischen Long- und Integer-Typen unterscheiden, deren wesentliche Unterschiede hervorheben und lernen, wie man effektiv mit jedem von ihnen arbeitet.

Prüfen, ob es sich um eine Instanz der Long-Klasse handelt

In diesem Schritt werden wir die Long-Klasse in Java untersuchen und lernen, wie man prüft, ob ein Objekt eine Instanz der Long-Klasse ist.

In Java sind primitive Datentypen wie long keine Objekte. Java bietet jedoch für jeden primitiven Typ Wrapper-Klassen an, und Long ist die Wrapper-Klasse für den primitiven Typ long. Wrapper-Klassen ermöglichen es uns, primitive Werte als Objekte zu behandeln, was in vielen Situationen nützlich ist, beispielsweise wenn man mit Sammlungen (Collections) arbeitet.

Um zu prüfen, ob ein Objekt eine Instanz einer bestimmten Klasse ist, verwenden wir den instanceof-Operator. Der instanceof-Operator ist ein binärer Operator, der verwendet wird, um zu testen, ob ein Objekt eine Instanz einer Klasse, einer Unterklasse oder eines Interfaces ist.

Lassen Sie uns ein einfaches Java-Programm erstellen, um zu demonstrieren, wie man den instanceof-Operator mit der Long-Klasse verwendet.

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor, wenn sie noch nicht geöffnet ist.

Ersetzen Sie den gesamten Inhalt der Datei durch folgenden Code:

public class HelloJava {
    public static void main(String[] args) {
        // Create a Long object
        Long myLong = 12345L;

        // Create an Integer object
        Integer myInteger = 67890;

        // Check if myLong is an instance of Long
        if (myLong instanceof Long) {
            System.out.println("myLong is an instance of Long.");
        } else {
            System.out.println("myLong is not an instance of Long.");
        }

        // Check if myInteger is an instance of Long
        if (myInteger instanceof Long) {
            System.out.println("myInteger is an instance of Long.");
        } else {
            System.out.println("myInteger is not an instance of Long.");
        }
    }
}

In diesem Code:

Wir erstellen ein Long-Objekt namens myLong mit dem Wert 12345L. Das Suffix L gibt an, dass es sich um ein long-Literal handelt.
Wir erstellen ein Integer-Objekt namens myInteger mit dem Wert 67890.
Wir verwenden den instanceof-Operator, um zu prüfen, ob myLong eine Instanz von Long ist.
Wir verwenden den instanceof-Operator, um zu prüfen, ob myInteger eine Instanz von Long ist.

Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das Programm, indem Sie den folgenden Befehl im Terminal ausführen:
```
javac HelloJava.java
```
Wenn die Kompilierung erfolgreich ist, sehen Sie keine Ausgabe.

Führen Sie das kompilierte Programm aus:

java HelloJava

Sie sollten die folgende Ausgabe sehen:

myLong is an instance of Long.
myInteger is not an instance of Long.

Diese Ausgabe bestätigt, dass myLong, das wir als Long-Objekt erstellt haben, tatsächlich eine Instanz der Long-Klasse ist, während myInteger, das als Integer-Objekt erstellt wurde, es nicht ist.

String in Long umwandeln

In diesem Schritt werden wir lernen, wie man die Zeichenketten-Repräsentation einer Zahl in ein Long-Objekt oder in den primitiven Typ long umwandelt. Dies ist eine häufige Aufgabe, wenn Sie numerische Daten als Text erhalten, beispielsweise von Benutzereingaben oder aus einer Datei.

Die Long-Klasse bietet statische Methoden, um diese Umwandlung durchzuführen. Die zwei am häufigsten verwendeten Methoden sind:

Long.parseLong(String s): Diese Methode interpretiert das String-Argument als vorzeichenbehaftete Dezimalzahl vom Typ long. Sie gibt einen primitiven long-Wert zurück.
Long.valueOf(String s): Diese Methode gibt ein Long-Objekt zurück, das den vom String-Argument repräsentierten Wert enthält.

Lassen Sie uns unser HelloJava.java-Programm ändern, um zu demonstrieren, wie man einen String in einen long-Wert und ein Long-Objekt umwandelt.

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor.

Ersetzen Sie den vorhandenen Code durch folgenden:

public class HelloJava {
    public static void main(String[] args) {
        String numberString = "9876543210";

        // Parse the string to a primitive long
        long primitiveLong = Long.parseLong(numberString);
        System.out.println("Parsed primitive long: " + primitiveLong);

        // Parse the string to a Long object
        Long longObject = Long.valueOf(numberString);
        System.out.println("Parsed Long object: " + longObject);

        // Demonstrate parsing a different string
        String anotherNumberString = "112233445566";
        long anotherPrimitiveLong = Long.parseLong(anotherNumberString);
        System.out.println("Parsed another primitive long: " + anotherPrimitiveLong);
    }
}

In diesem Code:

Wir definieren eine String-Variable numberString, die den Text "9876543210" enthält.
Wir verwenden Long.parseLong(), um numberString in einen primitiven long-Wert umzuwandeln und ihn in primitiveLong zu speichern.
Wir verwenden Long.valueOf(), um numberString in ein Long-Objekt umzuwandeln und es in longObject zu speichern.
Wir demonstrieren die Umwandlung einer anderen Zeichenkette, um die Flexibilität der Methode zu zeigen.

Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das Programm:
```
javac HelloJava.java
```
Stellen Sie sicher, dass keine Kompilierungsfehler auftreten.

Führen Sie das Programm aus:

java HelloJava

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Parsed primitive long: 9876543210
Parsed Long object: 9876543210
Parsed another primitive long: 112233445566

Diese Ausgabe zeigt, dass sowohl Long.parseLong() als auch Long.valueOf() die Zeichenketten-Repräsentationen von Zahlen erfolgreich in ihre entsprechenden long- und Long-Werte umgewandelt haben.

Es ist wichtig zu beachten, dass wenn die Zeichenkette keine gültige Zahl enthält, die als long dargestellt werden kann, diese Methoden eine NumberFormatException auslösen. Wir werden die Fehlerbehandlung in diesem einfachen Lab nicht behandeln, aber es ist etwas, das Sie bei realen Anwendungen im Hinterkopf behalten sollten.

Unterscheidung zwischen Long und Integer

In diesem Schritt werden wir uns darauf konzentrieren, die wichtigsten Unterschiede zwischen long (und seiner Wrapper-Klasse Long) und int (und seiner Wrapper-Klasse Integer) in Java zu verstehen. Obwohl beide zum Speichern ganzer Zahlen verwendet werden, unterscheiden sie sich erheblich in der Reichweite der Werte, die sie speichern können, und ihrer Speicherauslastung.

Der Hauptunterschied liegt in ihrer Größe:

int: Ein int ist ein 32-Bit vorzeichenbehafteter Zweierkomplement-Integer. Das bedeutet, dass es Werte im Bereich von -2.147.483.648 bis 2.147.483.647 speichern kann.
long: Ein long ist ein 64-Bit vorzeichenbehafteter Zweierkomplement-Integer. Dadurch kann es einen viel größeren Wertebereich speichern, nämlich von -9.223.372.036.854.775.808 bis 9.223.372.036.854.775.807.

Lassen Sie uns unser HelloJava.java-Programm ändern, um diesen Unterschied zu veranschaulichen.

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor.

Ersetzen Sie den vorhandenen Code durch folgenden:

public class HelloJava {
    public static void main(String[] args) {
        // Maximum value for int
        int maxInt = Integer.MAX_VALUE;
        System.out.println("Maximum value of int: " + maxInt);

        // Trying to store a value larger than maxInt in an int (will cause error if uncommented)
        // int tooBigInt = 2147483648; // This line would cause a compilation error

        // A value larger than maxInt, stored in a long
        long largeLong = 2147483648L; // Note the 'L' suffix
        System.out.println("A large value stored in long: " + largeLong);

        // Maximum value for long
        long maxLong = Long.MAX_VALUE;
        System.out.println("Maximum value of long: " + maxLong);

        // Demonstrating the size difference with literals
        System.out.println("Size of int in bits: " + Integer.SIZE);
        System.out.println("Size of long in bits: " + Long.SIZE);
    }
}

In diesem Code:

Wir geben den maximalen Wert aus, den ein int speichern kann, indem wir Integer.MAX_VALUE verwenden.
Wir zeigen eine auskommentierte Zeile, die einen Kompilierungsfehler verursachen würde, wenn sie einkommentiert würde, da der Wert 2147483648 größer als der maximale Wert eines int ist.
Wir speichern denselben großen Wert in einer long-Variablen largeLong und verwenden das Suffix L, um anzuzeigen, dass es sich um ein long-Literal handelt.
Wir geben den maximalen Wert aus, den ein long speichern kann, indem wir Long.MAX_VALUE verwenden.
Wir geben die Größe von int und long in Bits aus, indem wir Integer.SIZE und Long.SIZE verwenden.

Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das Programm:
```
javac HelloJava.java
```
Stellen Sie sicher, dass keine Kompilierungsfehler auftreten.

Führen Sie das Programm aus:

java HelloJava

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Maximum value of int: 2147483647
A large value stored in long: 2147483648
Maximum value of long: 9223372036854775807
Size of int in bits: 32
Size of long in bits: 64

Diese Ausgabe zeigt deutlich, dass long erheblich größere Werte speichern kann als int, und bestätigt ihre jeweiligen Größen in Bits. Wenn Sie zwischen int und long wählen, sollten Sie die Reichweite der Werte berücksichtigen, die Ihre Variable speichern muss. Verwenden Sie int für kleinere Zahlen, um Speicherplatz zu sparen, und long für größere Zahlen.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man prüft, ob eine Zahl in Java ein Long ist. Wir haben uns die Long-Wrapper-Klasse und ihre Beziehung zum primitiven long-Typ angeschaut. Insbesondere haben wir uns darauf konzentriert, den instanceof-Operator zu verwenden, um festzustellen, ob ein Objekt eine Instanz der Long-Klasse ist. Anhand eines praktischen Beispiels haben wir gezeigt, wie man instanceof anwendet, um zwischen Long- und Integer-Objekten zu unterscheiden.