Как да конвертирате long в int в Java

В тази статия ще обясним How да конвертирате long в int в Java и ще напишем някои примерни codeове. Тъй като long е по-голям тип данни от int , тук трябва да използваме преобразуване на типове за такова преобразуване. Както вероятно вече знаете, Howто long , така и int в Java са примитивни типове данни. Това означава, че те не са класови обекти. Всички обекти и масиви се съхраняват в Heap Space, докато примитивните типове като int и long се съхраняват в Stack паметта. Long и int са донякъде подобни. Цяло число означава цяло число, което може да бъде положително, отрицателно or нула. И двете дългии int са цели типове, така че са съвместими по няHowъв начин. Проблемът е, че дългият тип варира от -263 до 263 – 1, or -9223372036854775808 до 9223372036854775807. Тоест програмата на Java разпределя 64 бита за дълъг тип . В същото време типът int заема 32 бита, в които можете да поставите числа от -231 до 231 - 1 or, което е същото, от -2147483648 до 2147483647. Това означава, че всяко число от тип int може лесно да се побере в дълъг тип. В Java при работа с примитиви преобразуването от по-тесен тип в по-широк тип е автоматично. По друг начин се нарича разширяване.

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

Тук присвояваме int на дълга променлива. Всичко мина гладко, в по-голям диапазон, по-малък пасва тихо и не губим нищо освен място в паметта. Между другото, когато декларираме променлива от тип long и дефинираме нейната стойност, по-добре е да й присвоим буквата l , това ще бъде полезно, когато работим с числа извън диапазона int .

long myVeryLong = 10000000000l;

Java long към int преобразуване

Сега нека се върнем към основната задача на тази статия — преобразуване на Java long към int . Проблемът е, че нещо по-голямо не винаги се вписва в нещо по-малко. Така че тук не можем просто да поставим „по-малък“ в „по-голям“ автоматично в Java. Ако се опитаме да действаме Howто в предишния пример, но обратното:

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

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

Java компилаторът просто няма да ни позволи да направим това и ще изведе грешка. Така че за тази операция трябва да използваме това, което се нарича преобразуване на типове. Този процес се нарича преобразуване на стесняващ тип. За да стесните променлива, трябва изрично да посочите типа, към който искате да прехвърлите стойността си. Ето един пример, в който ще се опитаме да поставим едно „малко“ дълго в int (което трябва да се побере) и две „големи“ дълги числа, които са извън обхвата на int .

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

Уведомихме компилатора, че искаме да поставим дългата стойност в int променлива и носим отговорност за последствията от това решение. Компилаторът, виждайки изрично указание за по-тесен тип, извършва преобразуването. В резултат на това получаваме резултата: Е, 16 000 определено е това, което очаквахме да видим, но защо минусът е в -2147483648? И Howво означава това 1410065408? Факт е, че такива числа се съхраняват в дълга променлива, която, Howто си спомняме, отнема 64 бита. Опитваме се да поставим тези числа в int променлива, която може да съхранява само 32 бита. По правило тези 32 клетки ще съдържат нули и единици от първите 32 бита на дългото число, а останалите просто ще бъдат изхвърлени. Следователно, ако оригиналното число не се побира в 32 бита, тогава тези битове, които не се побират, просто се изхвърлят. Ето защо имаме само правилното число 16000, тъй като то заема по-малко от 32 бита.

Java 8 дълго към int преобразуване

В Java 8 класът Math има нов метод, който ще преобразува long в int . Ето го:

Math.toIntExact(value);

Най-хубавото при този метод е, че той контролира дължината на преобразуваното число и ако стойността е твърде голяма, за да се побере в int , ще хвърли изключение. Нека да видим How работи това в нашия пример:

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

Резултатът е: По този начин програмата отпечата единственото правилно преобразувано число 16000 и след това, когато се опита да натисне числото извън диапазона 2147483648l в int , методът хвърли изключение. Така че нямаме проблема с изхвърлените битове, Howто в случая с класическото преобразуване на Java long към int .