Hoe lang naar int in Java te converteren

In dit artikel gaan we uitleggen hoe je long naar int converteert in Java en enkele codevoorbeelden schrijven. Aangezien long een groter gegevenstype is dan int , moeten we hier typecasting gebruiken voor een dergelijke conversie. Zoals u waarschijnlijk al weet, zijn long en int in Java primitieve gegevenstypen. Dat betekent dat het geen klasseobjecten zijn. Alle objecten en arrays worden opgeslagen in Heap Space, terwijl primitieve typen zoals int en long worden opgeslagen in Stack-geheugen. Long en int lijken enigszins op elkaar. Integer betekent geheel getal, dat positief, negatief of nul kan zijn. Beide langen int zijn integer-typen, dus ze zijn in zekere zin compatibel. Het probleem is dat het lange type varieert van -263 tot 263 – 1, of -9223372036854775808 tot 9223372036854775807. Dat wil zeggen, het Java-programma wijst 64 bits toe aan een lang type. Tegelijkertijd neemt het int- type 32 bits in beslag, waarin u getallen kunt plaatsen van -231 tot 231 - 1 of, wat hetzelfde is, van -2147483648 tot 2147483647. Dit betekent dat elk getal van het int- type gemakkelijk in een lange soort. Bij het werken met primitieven in Java is de conversie van een smaller type naar een breder type automatisch. Op een andere manier wordt het verbreding genoemd.

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

Hier wijzen we een int toe aan een lange variabele. Alles ging vlot, in een groter bereik past een kleinere stilletjes en verliezen we niets behalve geheugenruimte. Trouwens, als we een variabele van het type long declareren en de waarde ervan definiëren, is het beter om er de letter l aan toe te wijzen, dit is handig als we werken met getallen buiten het int- bereik.

long myVeryLong = 10000000000l;

Java long naar int conversie

Laten we nu teruggaan naar de hoofdtaak van dit artikel: conversie van Java long naar int . Het probleem is dat iets groters niet altijd in iets kleiners past. Dus hier kunnen we in Java niet automatisch "kleiner" in "groter" zetten. Als we proberen te handelen zoals in het vorige voorbeeld, maar omgekeerd:

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

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

De Java-compiler laat ons dit gewoon niet doen en geeft een foutmelding. Dus voor deze bewerking moeten we gebruik maken van wat typecasting wordt genoemd. Dit proces wordt vernauwende typeconversie genoemd. Om een ​​variabele te verfijnen, moet u expliciet het type specificeren waarnaar u uw waarde wilt casten. Hier is een voorbeeld waarbij we gaan proberen om één "kleine" lange naar int te plaatsen (die zou moeten passen) en twee "grote" lange getallen die buiten het int- bereik vallen.

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

We hebben de compiler laten weten dat we de lange waarde in een int- variabele willen zetten en we zijn verantwoordelijk voor de gevolgen van deze beslissing. De compiler, die een expliciete indicatie van een smaller type ziet, voert de conversie uit. Als resultaat krijgen we de uitvoer: Nou, 16000 is zeker wat we verwachtten te zien, maar waarom is min in -2147483648? En wat betekent deze 1410065408? Het feit is dat dergelijke getallen werden opgeslagen in een lange variabele, die, zoals we ons herinneren, 64 bits kost. We proberen deze getallen in een int- variabele te plaatsen die slechts 32 bits kan opslaan. In de regel bevatten deze 32 cellen nullen en enen van de eerste 32 bits van het lange getal, en de rest wordt gewoon weggegooid. Daarom, als het oorspronkelijke nummer niet in 32 bits past, worden de bits die niet passen gewoon weggegooid. Daarom hebben we alleen het juiste getal 16000, aangezien het minder dan 32 bits in beslag neemt.

Java 8 lang naar int conversie

In Java 8 heeft de klasse Math een nieuwe methode die long converteert naar int . Hier is het:

Math.toIntExact(value);

Het beste van deze methode is dat het de lengte van het geconverteerde getal regelt, en als de waarde te groot is om in een int te passen , wordt er een uitzondering gegenereerd. Laten we eens kijken hoe dit werkt in ons voorbeeld:

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

De uitvoer is: Het programma drukte dus het enige correct geconverteerde nummer 16000 af, en toen het probeerde het buiten-bereik-nummer 2147483648l naar int te pushen , veroorzaakte de methode een uitzondering. We hebben dus niet het probleem van weggegooide bits, zoals in het geval van de klassieke Java- conversie van long naar int .