Primitive Java-konverteringer

1. Introduktion

Java er et skrevet sprog, hvilket betyder, at det bruger begrebet typer. Der er to forskellige typegrupper:

  1. primitive datatyper
  2. abstrakte datatyper.

I denne artikel vil vi fokusere på konverteringer af primitive typer.

2. Oversigt over primitiver

Den første ting, vi skal vide, er, hvilken slags værdier der kan bruges med primitive typer. Der er otte primitive typer, som er:

  • byte - 8 bits og signeret

  • kort - 16 bits og signeret

  • char - 16 bits og usigneret, så det kan repræsentere Unicode-tegn

  • int - 32 bits og signeret

  • lang - 64 bits og signeret

  • flyde - 32 bits og signeret

  • dobbelt - 64 bits og signeret

  • boolsk - det er ikke numerisk, kan kun have rigtigt eller falsk værdier

Dette er ikke beregnet til at være en omfattende diskussion om primitiver, og vi vil tale lidt mere om deres detaljer efter behov under konverteringerne.

3. Udvidelse af primitive konverteringer

Når vi har brug for at konvertere fra en primitiv, der er enklere eller mindre end destinationstypen, behøver vi ikke bruge nogen særlig notation til det:

int myInt = 127; lang myLong = minInt;

Under udvidelse af konvertering placeres den mindre primitive værdi over en større container, hvilket betyder, at al den ekstra plads til venstre for værdien er fyldt med nuller. Dette kan også bruges til at gå fra heltalsgruppen til flydende punkt:

flyde myFloat = myLong; dobbelt myDouble = myLong;

Dette er muligt, fordi flytningen til en bredere primitiv ikke mister nogen information.

4. Indskrænkning af primitiv konvertering

Nogle gange er vi nødt til at tilpasse en værdi, der er større end den type, der anvendes i variabelangivelsen. Dette kan resultere i tab af information, da nogle byte skal kasseres.

I dette tilfælde skal vi udtrykkeligt udtrykke, at vi er opmærksomme på situationen, og vi er enige i det ved at bruge en rollebesætning:

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

5. Udvidelse og indsnævring af primitiv konvertering

Denne situation sker i en meget specifikt tilfælde, når vi vil konvertere fra en byte til en char. Den første konvertering er udvidelsen af byte til int og derefter fra int det er indsnævret til char.

Et eksempel vil tydeliggøre dette punkt:

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

Den binære repræsentation af 130 er den samme for -126, forskellen er fortolkningen af ​​signalbiten. Lad os nu konvertere fra byte til char:

char myLargeValueChar = (char) myLargeValueByte; // 0b11111111 10000010 usigneret værdi int myLargeValueInt = myLargeValueChar; // 0b11111111 10000010 65410

Det char repræsentation er en Unicode-værdi, men konvertering til en int viste os en meget stor værdi, som har de nederste 8 bits nøjagtigt det samme som -126.

Hvis vi konverterer det igen til byte vi får:

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

Den oprindelige værdi, som vi brugte. Hvis hele koden startede med en char værdierne vil være forskellige:

char myLargeValueChar2 = 130; // Dette er en int ikke en byte! // 0b 00000000 10000010 usigneret værdi int myLargeValueInt2 = myLargeValueChar2; // 0b00000000 10000010 130 byte myOtherByte2 = (byte) myLargeValueInt2; // 0b10000010 -126

Selvom byte repræsentation er den samme, hvilket er -126, char repræsentation giver os to forskellige karakterer.

6. Konvertering af boksning / unboxing

I Java har vi en Wrapper-klasse for hver primitive type, dette er en smart måde at give programmører nyttige behandlingsmetoder uden overhead at have alt som en tungvægsobjektreference. Siden Java 1.5 var muligheden for automatisk at konvertere til / fra en primitiv til et objekt og tilbage inkluderet, og dens opnåede ved simpel tilskrivning:

Heltal myIntegerReference = myInt; int myOtherInt = myIntegerReference;

7. Strengkonverteringer

Alle de primitive typer kan konverteres til Snor gennem deres indpakningsklasser, der tilsidesætter toString () metode:

String myString = myIntegerReference.toString ();

Hvis vi har brug for at gå tilbage til en primitiv type, skal vi bruge en analyseringsmetode defineret af den tilsvarende indpakningsklasse:

byte myNewByte = Byte.parseByte (myString); kort myNewShort = Short.parseShort (myString); int myNewInt = Integer.parseInt (myString); lang myNewLong = Long.parseLong (myString); flyde myNewFloat = Float.parseFloat (myString); dobbelt myNewDouble = Double.parseDouble (myString); 
boolsk myNewBoolean = Boolean.parseBoolean (myString);

Den eneste undtagelse her er Karakter Klasse, fordi en Snor er lavet af chars alligevel, denne måde, i betragtning af at sandsynligvis den Snor er lavet af en enkelt char, kan vi bruge charAt () metode til Snor klasse:

char myNewChar = myString.charAt (0);

8. Numeriske forfremmelser

For at udføre en binær operation er det nødvendigt, at begge operander er kompatible med hensyn til størrelse.

Der er et sæt enkle regler, der gælder:

  1. Hvis en af ​​operanderne er en dobbelt, den anden forfremmes til dobbelt
  2. Ellers hvis en af ​​operanderne er en flyde, den anden forfremmes til flyde
  3. Ellers hvis en af ​​operanderne er en lang, den anden forfremmes til lang
  4. Ellers overvejes begge int

Lad os se et eksempel:

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

Begge operander blev forfremmet til int og resultatet skal nedkastes til byte igen.

9. Konklusion

Konvertering mellem typer er en meget almindelig opgave for daglige programmeringsaktiviteter. Der er et sæt regler, der styrer de måder, hvorpå statisk typede sprog fungerer disse konverteringer. At kende disse regler kan spare meget tid, når man prøver at finde ud af, hvorfor en bestemt kode kompileres eller ej.

Koden, der bruges i denne artikel, kan findes på GitHub.