Primitive Java-konverteringer

1. Introduksjon

Java er et maskinskrevet språk som betyr at det bruker begrepet typer. Det er to forskjellige typegrupper:

  1. primitive datatyper
  2. abstrakte datatyper.

I denne artikkelen vil vi fokusere på konvertering av primitive typer.

2. Oversikt over primitiver

Det første vi må vite er hva slags verdier som kan brukes med primitive typer. Det er åtte primitive typer som er:

  • byte - 8 bits og signert

  • kort - 16 bits og signert

  • røye - 16 bits og usignert, slik at det kan representere Unicode-tegn

  • int - 32 bits og signert

  • lang - 64 bits og signert

  • flyte - 32 bits og signert

  • dobbelt - 64 bits og signert

  • boolsk - det er ikke numerisk, kan bare ha ekte eller falsk verdier

Dette er ikke ment som en omfattende diskusjon om primitiver, og vi vil snakke litt mer om deres detaljer etter behov under konverteringen.

3. Utvidelse av primitive konverteringer

Når vi trenger å konvertere fra en primitiv som er enklere eller mindre enn destinasjonstypen, trenger vi ikke bruke noen spesiell notasjon for det:

int myInt = 127; lenge myLong = myInt;

Under utvidelse av konvertering plasseres den mindre primitive verdien over en større container, noe som betyr at all ekstra plass, til venstre for verdien, er fylt med nuller. Dette kan også brukes til å gå fra heltallgruppen til flytpunktet:

flyte myFloat = myLong; dobbelt myDouble = myLong;

Dette er mulig fordi flyttingen til en bredere primitiv ikke mister informasjon.

4. Innsnevring av primitiv konvertering

Noen ganger må vi tilpasse en verdi som er større enn typen som brukes i variabelerklæringen. Dette kan føre til tap av informasjon siden noen byte må kastes.

I dette tilfellet må vi eksplisitt uttrykke at vi er klar over situasjonen, og vi er enige i det ved å bruke en rollebesetning:

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

5. Utvidelse og innsnevring av primitiv konvertering

Denne situasjonen skjer i en veldig spesifikt tilfelle når vi vil konvertere fra en byte til en røye. Den første konvertering er utvidelsen av byte til int og deretter fra int det er innsnevret til røye.

Et eksempel vil avklare dette punktet:

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

Den binære representasjonen av 130 er den samme for -126, forskjellen er tolkningen av signalbiten. La oss nå konvertere fra byte til røye:

char myLargeValueChar = (char) myLargeValueByte; // 0b11111111 10000010 usignert verdi int myLargeValueInt = myLargeValueChar; // 0b11111111 10000010 65410

De røye representasjon er en Unicode-verdi, men konvertering til en int viste oss en veldig stor verdi som har de nedre 8 bitene nøyaktig den samme som -126.

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

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

Den opprinnelige verdien vi brukte. Hvis hele koden begynte med en røye verdiene vil være forskjellige:

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

Selv om byte representasjon er den samme, som er -126, røye representasjon gir oss to forskjellige karakterer.

6. Boksing / Unboxing-konvertering

I Java har vi en Wrapper-klasse for hver primitive type, dette er en smart måte å gi programmerere nyttige prosesseringsmetoder, uten overhead å ha alt som en tungvektobjektreferanse. Siden Java 1.5 ble muligheten for å konvertere til / fra en primitiv til et objekt og tilbake automatisk inkludert og oppnådd ved enkel tilskrivning:

Integer myIntegerReference = myInt; int myOtherInt = myIntegerReference;

7. Strengkonverteringer

Alle primitive typer kan konverteres til String gjennom Wrapper Classes, som overstyrer toString () metode:

String myString = myIntegerReference.toString ();

Hvis vi trenger å gå tilbake til en primitiv type, må vi bruke en analyseringsmetode definert av den tilsvarende Wrapper-klassen:

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

Det eneste unntaket her er Karakter Klasse fordi a String er laget av røyes uansett, på denne måten, med tanke på at sannsynligvis String er laget av en singel røye, kan vi bruke charAt () metoden for String klasse:

char myNewChar = myString.charAt (0);

8. Numeriske kampanjer

For å utføre en binær operasjon er det nødvendig at begge operandene er kompatible når det gjelder størrelse.

Det er et sett med enkle regler som gjelder:

  1. Hvis en av operandene er en dobbelt, den andre forfremmes til dobbelt
  2. Ellers hvis en av operandene er en flyte, den andre blir forfremmet til flyte
  3. Ellers hvis en av operandene er en lang, den andre blir forfremmet til lang
  4. Ellers blir begge vurdert int

La oss se et eksempel:

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

Begge operandene ble forfremmet til int og resultatet må være nedslått til byte en gang til.

9. Konklusjon

Konvertering mellom typer er en veldig vanlig oppgave i daglige programmeringsaktiviteter. Det er et sett med regler som styrer hvordan statiske typede språk driver disse konverteringene. Å vite disse reglene kan spare mye tid når du prøver å finne ut hvorfor en bestemt kode kompileres eller ikke.

Koden som brukes i denne artikkelen finner du på GitHub.