Sådan konverteres long til int i Java

I denne artikel skal vi forklare, hvordan man konverterer long til int i Java og skriver nogle kodeeksempler. Da long er en større datatype end int , bør vi her bruge typecasting til en sådan konvertering. Som du sikkert allerede ved, er både long og int i Java primitive datatyper. Det betyder, at de ikke er klasseobjekter. Alle objekter og arrays gemmes i Heap Space, mens primitive typer såsom int og long gemmes i Stack-hukommelsen. Long og int ligner noget. Heltal betyder et helt tal, der kan være positivt, negativt eller nul. Begge langeog int er heltalstyper, så de er kompatible på en måde. Problemet er, at den lange type går fra -263 til 263 – 1, eller -9223372036854775808 til 9223372036854775807. Det vil sige, at Java-programmet allokerer 64 bit til en lang type. Samtidig optager int type 32 bit, hvori du kan sætte tal fra -231 til 231 - 1 eller, som er det samme, fra -2147483648 til 2147483647. Det betyder, at et hvilket som helst antal af int type nemt kan passe ind i en lang type. I Java, når man arbejder med primitiver, er konverteringen fra en smallere type til en bredere type automatisk. På en anden måde kaldes det udvidelse.

int myInt= 18;
long myLong= 16000;
       myLong = myInt;

Her tildeler vi en int til en lang variabel. Alt gik glat, i et større område, en mindre passer stille og roligt og vi mister ikke andet end hukommelsesplads. Forresten, når vi erklærer en variabel af typen lang og definerer dens værdi, er det bedre at tildele den bogstavet l , dette vil være nyttigt, når vi arbejder med tal uden for int- området.

long myVeryLong = 10000000000l;

Java long til int konvertering

Lad os nu vende tilbage til hovedopgaven i denne artikel - Java long to int konvertering. Problemet er, at noget større ikke altid passer ind i noget mindre. Så her kan vi ikke bare sætte "mindre" ind i "større" automatisk i Java. Hvis vi prøver at handle som i det foregående eksempel, men omvendt:

//example without typecasting…nice trying!
public static void main(String[] args) {

int myInt= 18;
long myLong= 16000;
       myInt = myLong;
}

Java-kompiler vil bare ikke lade os gøre dette og vil give en fejl. Så til denne operation skal vi bruge det, der kaldes typecasting. Denne proces kaldes indsnævringstypekonvertering. For at indsnævre en variabel skal du udtrykkeligt angive den type, som du vil caste din værdi til. Her er et eksempel, hvor vi skal forsøge at sætte en "lille" lang til int (der burde passe ind) og to "store" lange tal, der er uden for int interval.

public class longToInt {

   public static void main(String[] args) {

       int myInt = 18;
       long myLong = 16000;
       long myVeryLong = 2147483648l;//l in the end means ‘long’
       long myVeryLong = 10000000000l;

       myInt = (int) myLong;
       System.out.println(myInt);
       myInt = (int) oneMoreLong;
       System.out.println(myInt);
       myInt = (int) myVeryLong;
       System.out.println(myInt);
   }
}

Vi har meddelt compileren, at vi ønsker at sætte den lange værdi ind i en int- variabel, og vi er ansvarlige for konsekvenserne af denne beslutning. Compileren, der ser en eksplicit indikation af en smallere type, udfører konverteringen. Som et resultat får vi output: Nå, 16000 er bestemt, hvad vi forventede at se, men hvorfor er minus i -2147483648? Og hvad betyder denne 1410065408? Faktum er, at sådanne tal blev gemt i en lang variabel, som, som vi husker, tager 64 bit. Vi forsøger at sætte disse tal ind i en int- variabel, der kun kan gemme 32 bit. Som regel vil disse 32 celler indeholde nuller og ettaller fra de første 32 bit af det lange tal, og resten vil simpelthen blive kasseret. Derfor, hvis det oprindelige nummer ikke passer ind i 32 bit, så bliver de bits, der ikke passer, simpelthen kasseret. Derfor har vi kun det rigtige tal 16000, da det fylder mindre end 32 bit.

Java 8 long til int konvertering

I Java 8 har Math- klassen en ny metode, der vil konvertere long til int . Her er det:

Math.toIntExact(value);

Det bedste ved denne metode er, at den styrer længden af ​​det konverterede tal, og hvis værdien er for stor til at passe ind i en int , vil den give en undtagelse. Lad os se, hvordan dette fungerer i vores eksempel:

public class intToLong {

   public static void main(String[] args) {

       int myInt = 18;
       long myLong = 16000;
       long oneMoreLong = 2147483648l;
       long myVeryLong = 10000000000l;

       System.out.println(Math.toIntExact(myLong));
       int y = Math.toIntExact(oneMoreLong);
       System.out.println(oneMoreLong);
       System.out.println(Math.toIntExact(myVeryLong));
   }
}

Udgangen er: Programmet udskrev således det eneste korrekt konverterede nummer 16000, og da man forsøgte at skubbe nummeret 2147483648l uden for rækkevidde ind i int , gav metoden en undtagelse. Så vi har ikke problemet med kasserede bits, som i tilfældet med klassisk Java long til int konvertering.