Hur man konverterar long till int i Java

I den här artikeln kommer vi att förklara hur man konverterar long till int i Java och skriver några kodexempel. Eftersom long är en större datatyp än int bör vi här använda typcasting för sådan konvertering. Som du säkert redan vet är både long och int i Java primitiva datatyper. Det betyder att de inte är klassobjekt. Alla objekt och arrayer lagras i Heap Space medan primitiva typer som int och long lagras i Stack-minnet. Long och int är något lika. Heltal betyder heltal, som kan vara positivt, negativt eller noll. Båda långaoch int är heltalstyper, så de är kompatibla på ett sätt. Problemet är att den långa typen sträcker sig från -263 till 263 – 1, eller -9223372036854775808 till 9223372036854775807. Det vill säga Java-programmet allokerar 64 bitar för en lång typ. Samtidigt upptar int- typ 32 bitar, i vilka du kan sätta tal från -231 till 231 - 1 eller, vilket är detsamma, från -2147483648 till 2147483647. Detta betyder att valfritt antal int-typer lätt kan passa in i en lång typ. I Java, när man arbetar med primitiver, är omvandlingen från en smalare typ till en bredare typ automatisk. På ett annat sätt kallas det breddning.

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

Här tilldelar vi en int till en lång variabel. Allt gick smidigt, i ett större sortiment, en mindre passar tyst och vi tappar inget förutom minnesutrymme. Förresten, när vi deklarerar en variabel av typen long och definierar dess värde, är det bättre att tilldela bokstaven l till den, detta kommer att vara praktiskt när vi arbetar med siffror utanför int -intervallet.

long myVeryLong = 10000000000l;

Java long till int konvertering

Låt oss nu gå tillbaka till huvuduppgiften för denna artikel - Java long to int- konvertering. Problemet är att något större inte alltid passar in i något mindre. Så här kan vi inte bara lägga "mindre" till "större" automatiskt i Java. Om vi ​​försöker agera som i föregående exempel, men vice versa:

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

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

Java-kompilatorn låter oss bara inte göra detta och kommer att ge ett fel. Så för denna operation måste vi använda det som kallas typecasting. Denna process kallas omvandling av avsmalnande typ. För att begränsa en variabel måste du uttryckligen ange vilken typ du vill casta ditt värde till. Här är ett exempel där vi ska försöka sätta ett "litet" långt till int (som borde passa in) och två "stora" långa tal som ligger utanför int -intervallet.

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 meddelat kompilatorn att vi vill lägga det långa värdet i en int- variabel och vi är ansvariga för konsekvenserna av detta beslut. Kompilatorn, som ser en explicit indikation av en smalare typ, utför konverteringen. Som ett resultat får vi utdata: Tja, 16000 är definitivt vad vi förväntade oss att se, men varför är minus i -2147483648? Och vad betyder denna 1410065408? Faktum är att sådana nummer lagrades i en lång variabel, som, som vi minns, tar 64 bitar. Vi försöker lägga in dessa siffror i en int -variabel som bara kan lagra 32 bitar. Som regel kommer dessa 32 celler att innehålla nollor och ettor från de första 32 bitarna av det långa numret, och resten kommer helt enkelt att kasseras. Därför, om det ursprungliga numret inte passar in i 32 bitar, så kasseras de bitar som inte passar helt enkelt. Det är därför vi bara har rätt siffra 16000, eftersom det tar upp mindre än 32 bitar.

Java 8 long till int konvertering

I Java 8 har Math -klassen en ny metod som konverterar long till int . Här är det:

Math.toIntExact(value);

Det bästa med den här metoden är att den styr längden på det konverterade talet, och om värdet är för stort för att passa in i en int , kommer det att skapa ett undantag. Låt oss se hur detta fungerar i vårt exempel:

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));
   }
}

Utgången är: Således skrev programmet ut det enda korrekt konverterade numret 16000, och när man sedan försökte trycka in numret 2147483648l utanför intervallet till int , gav metoden ett undantag. Så vi har inte problemet med kasserade bitar, som i fallet med klassisk Java long till int -konvertering.