Java Primitive Conversions

1. Einleitung

Java ist eine typisierte Sprache, dh es wird das Konzept der Typen verwendet. Es gibt zwei verschiedene Typgruppen:

  1. primitive Datentypen
  2. abstrakte Datentypen.

In diesem Artikel konzentrieren wir uns auf Konvertierungen primitiver Typen.

2. Übersicht der Grundelemente

Das erste, was wir wissen müssen, ist, welche Art von Werten mit primitiven Typen verwendet werden können. Es gibt acht primitive Typen:

  • Byte - 8 Bit und signiert

  • kurz - 16 Bit und signiert

  • char - 16 Bit und ohne Vorzeichen, damit es Unicode-Zeichen darstellen kann

  • int - 32 Bit und signiert

  • lang - 64 Bit und signiert

  • float - 32 Bit und signiert

  • doppelt - 64 Bit und signiert

  • boolean - es ist nicht numerisch, kann nur wahre oder falsche Werte haben

Dies ist keine ausführliche Diskussion über Grundelemente, und wir werden bei Bedarf während der Konvertierungen etwas mehr über deren Details sprechen.

3. Erweiterung primitiver Konvertierungen

Wenn wir von einem Grundelement konvertieren müssen, das einfacher oder kleiner als der Zieltyp ist, müssen wir dafür keine spezielle Notation verwenden:

int myInt = 127; long myLong = myInt;

Während der erweiterten Konvertierung wird der kleinere Grundwert über einen größeren Container gelegt, was bedeutet, dass der gesamte zusätzliche Platz links vom Wert mit Nullen gefüllt ist. Dies kann auch verwendet werden, um von der Ganzzahlgruppe zum Gleitkomma zu gelangen:

float myFloat = myLong; double myDouble = myLong;

Dies ist möglich, weil beim Übergang zu einem breiteren Grundelement keine Informationen verloren gehen.

4. Eingrenzen der primitiven Konvertierung

Manchmal müssen wir einen Wert anpassen, der größer ist als der in der Variablendeklaration verwendete Typ. Dies kann zu Informationsverlust führen, da einige Bytes verworfen werden müssen.

In diesem Fall müssen wir ausdrücklich zum Ausdruck bringen, dass wir uns der Situation bewusst sind, und wir stimmen dem zu, indem wir eine Besetzung verwenden:

int myInt = (int) myDouble; byte myByte = (byte) myInt;

5. Erweiterung und Verengung der primitiven Umwandlung

Diese Situation tritt in einem ganz bestimmten Fall auf, wenn wir von einem Byte in ein Zeichen konvertieren möchten . Die erste Konvertierung ist die Erweiterung des Bytes zu int und dann von int zu char .

Ein Beispiel verdeutlicht diesen Punkt:

byte myLargeValueByte = (byte) 130; //0b10000010 -126

Die binäre Darstellung von 130 ist für -126 gleich, der Unterschied ist die Interpretation des Signalbits. Lassen Sie uns nun von Byte zu Zeichen konvertieren :

char myLargeValueChar = (char) myLargeValueByte; //0b11111111 10000010 unsigned value int myLargeValueInt = myLargeValueChar; //0b11111111 10000010 65410

Die char- Darstellung ist ein Unicode-Wert, aber die Konvertierung in ein int hat uns einen sehr großen Wert gezeigt, dessen untere 8 Bits genau gleich -126 sind.

Wenn wir es erneut in Byte konvertieren, erhalten wir:

byte myOtherByte = (byte) myLargeValueInt; //0b10000010 -126

Der ursprüngliche Wert, den wir verwendet haben. Wenn der gesamte Code mit einem Zeichen begann, sind die Werte unterschiedlich:

char myLargeValueChar2 = 130; //This is an int not a byte! //0b 00000000 10000010 unsigned value int myLargeValueInt2 = myLargeValueChar2; //0b00000000 10000010 130 byte myOtherByte2 = (byte) myLargeValueInt2; //0b10000010 -126

Obwohl die Byte - Darstellung ist das gleiche, die -126 ist, das Zeichen gibt Darstellung uns zwei verschiedene Charaktere.

6. Boxing / Unboxing-Konvertierung

In Java haben wir eine Wrapper-Klasse für jeden primitiven Typ. Dies ist eine clevere Möglichkeit, Programmierern nützliche Verarbeitungsmethoden zur Verfügung zu stellen, ohne den Aufwand, alles als schwere Objektreferenz zu haben. Seit Java 1.5 war die Möglichkeit zur automatischen Konvertierung in / von einem Grundelement in ein Objekt und zurück enthalten und wurde durch einfache Zuordnung erreicht:

Integer myIntegerReference = myInt; int myOtherInt = myIntegerReference;

7. String-Konvertierungen

Alle primitiven Typen können über ihre Wrapper-Klassen, die die toString () -Methode überschreiben, in String konvertiert werden:

String myString = myIntegerReference.toString();

Wenn wir zu einem primitiven Typ zurückkehren möchten, müssen wir eine Analysemethode verwenden, die durch die entsprechende Wrapper-Klasse definiert ist:

byte myNewByte = Byte.parseByte(myString); short myNewShort = Short.parseShort(myString); int myNewInt = Integer.parseInt(myString); long myNewLong = Long.parseLong(myString); float myNewFloat = Float.parseFloat(myString); double myNewDouble = Double.parseDouble(myString); 
boolean myNewBoolean = Boolean.parseBoolean(myString);

The only exception here is the Character Class because a String is made of chars anyway, this way, considering that probably the String is made of a single char, we can use the charAt() method of the String class:

char myNewChar = myString.charAt(0);

8. Numeric Promotions

To execute a binary operation, it is necessary that both operands are compatible in terms of size.

There is a set of simple rules that apply:

  1. If one of the operands is a double, the other is promoted to double
  2. Otherwise, if one of the operands is a float, the other is promoted to float
  3. Wenn andernfalls einer der Operanden lang ist , wird der andere zu lang befördert
  4. Andernfalls werden beide als int betrachtet

Sehen wir uns ein Beispiel an:

byte op1 = 4; byte op2 = 5; byte myResultingByte = (byte) (op1 + op2);

Beide Operanden wurden auf int hochgestuft und das Ergebnis muss erneut auf Byte heruntergestuft werden.

9. Fazit

Die Konvertierung zwischen Typen ist eine sehr häufige Aufgabe bei täglichen Programmieraktivitäten. Es gibt eine Reihe von Regeln, die regeln, wie statisch typisierte Sprachen diese Konvertierungen ausführen. Wenn Sie diese Regeln kennen, können Sie viel Zeit sparen, wenn Sie herausfinden möchten, warum ein bestimmter Code kompiliert wird oder nicht.

Der in diesem Artikel verwendete Code ist auf GitHub zu finden.