Разлика между int и long
Съдържание
Типовете данни int и long са сред двата типа цели данни, описани в Java. В Java типовете int и long са подписани, + ve и -ve стойности. Java не поддържа неподписани типове int и long. Основната разлика между типа int и long data е ширината на всеки тип. Типът int на типа има ширина 32-битова за променливата от тип int. От друга страна, типът данни long има ширината 64-битова за променливата от long type. Сравнителната диаграма по-долу показва някои други разлики между int и long.
- Сравнителна диаграма
- дефиниция
- Ключови разлики
- заключение
Сравнителна диаграма
| Основа за сравнение | инт | дълго |
|---|---|---|
| Основен | Входът на типа данни е от 32 бита. | Типът данни е дълъг от 64 бита. |
| Bytes | Ако се брои в байтове, int е 4 байта. | Ако се брои в байтове, дългият е 8 байта. |
| диапазон | В Java обхвата на типа int е –2,147,483,648 до 2,147,483,647. | В Java обхвата от тип е дълъг –9,223,372,036,854,775,808 до 9,223,372,036,854,775,807. |
| Ключова дума | Ключовата дума, използвана за деклариране на променлива от тип int, е „int“. | Ключовата дума, използвана за деклариране на променлива от дълъг тип, е „дълга“. |
| памет | Паметта, необходима за съхранение на променлива на int, е по-малка в сравнение с дългата. | Паметта, необходима за съхраняване на дълга променлива, е по-голяма в сравнение с int. |
Дефиниция на тип int
Типът данни int е най-често използваният тип данни, който съдържа цяло число в него. Стойност, която може да съдържа int променлива, не е твърде къса и не твърде дълга. Обикновено стойността на int променлива се използва като циклична променлива, която контролира цикъла, или се използва като индексна променлива на масив. Типът байт и кратък тип данни имат по-кратък диапазон в сравнение с типа данни int, но те не могат да заменят int, дори ако стойността на int променлива е с по-малък диапазон. Причината за това е, че когато използваме тип данни байт и кратък в израз, тогава докато оценяваме този израз, типът данни на байт и кратък се повишава в int от компилатора. И така, от това може да се каже, че е по-добре да се използва int, където е необходимо цяло число.
Нека разгледаме използването на int тип данни.
байт a = 70; байт b = 80; int c = a * b; // няма грешка байт d = a + 10; // Грешка във времето за компилиране.
Както можете да видите в горния код двете, байтови променливи a и b, съдържащи стойност 70 и 80, която е валидна байтова стойност. Но, междинният резултат на a * b; надвишава границата на байта. Следователно компилаторът автоматично промотира байтовите, кратките и char променливите за въвеждане на int, ако те се използват в израз. Сега можете да видите, че резултатът от * b е присвоен на int променлива, която не причинява никаква грешка и се компилира гладко, защото променливите a и b се повишават до type int и присвояване на type int на типа int doesn ' не причинява грешката.
В последния ред на кода можете да видите израз, при който стойността 10 се добавя към байтова променлива „a“, резултатът от нея все още не надхвърля ограничението на байта. Но присвояването на междинния резултат от израза „a + 10“ на байтовата променлива „d“, причинява грешка във времето на компилиране, тъй като докато байтовата променлива за оценка на израз „a“ се повишава до типа int. И присвояване на тип int на тип байт не е позволено. Следователно, това причинява грешка във времето за компилиране.
Определение за дълъг тип
Типът данни има най-голям обхват и ширина в сравнение с байтови, къси и int типове. В Java, типът long е 64-битов подписан цяло число. Типът long се използва там, където типът int не е толкова голям, за да задържи желаната стойност. Диапазонът на дългите е –9,223,372,036,854,775,808 до 9,223,372,036,854,775,807, което е доста голямо, за да държи по-големите стойности като големи цели числа. Можем да разберем типа дълго с пример по-долу.
тегло тегло {public static void main (String args) {int item; int wt_per_item; дълги грама; дълга кутия; артикул = 10000000; // посочете брой елементи wt_per_item = 10000; // посочете тегло на един артикул в килограми = wt_item * 1000; // преобразувайте теглото в грам Box = item * gram; // изчисляване на теглото на кутията в грамове System.out.ln ("Брой на артикула" + елемент); System.out.ln ("Тегло на артикул" + wt_per_item + "килограми"); System.out.ln ("Тегло на кутията в грам" + кутия + "килограми"); }} Брой на артикула 10000000 Тегло за артикул 10000 килограма Тегло на кутията в грам 100000000000000 килограма
Спазвайте изхода в горния код; резултатът се изчислява за теглото на цялата кутия, съдържаща кутия, съдържаща 10000000 артикула, от които на един артикул тежи 10000 килограма. Изчислената стойност за теглото на кутията в грамове не може да бъде задържана от int променлива. Следователно, понякога се налага да се използва дълъг тип, когато се изчисляват или задържат големи стойности.
- Основната разлика между типа int и long е в тяхната ширина, където int е 32 бита, а long е 64 бита.
- Типовете int и long, когато се броят в байтове, вместо bits, типът int е 4 байта, а типът long е само два пъти, ако type int, т.е. 8 байта.
- В Java диапазонът на типа int е от –2,147,483,648 до 2,147,483,647, докато диапазонът от тип дълги е от –9,223,372,036,854,775,808 до 9,223,372,036,854,775,807, което е много по-голямо от типа int.
- Ключовата дума, използвана за деклариране на променлива от типа int, е „int“. От друга страна, ключовата дума, използвана за деклариране на променливата от тип long, е „long“.
- По принцип паметта, необходима за задържане на стойността на типа int, е по-малка в сравнение с дългата.
Заключение:
Докато пишете код, ако има нужда от средна стойност на диапазона, тогава можете да използвате типа int, но когато изходът, произведен от който и да е израз, ще бъде по-голям или по-големите стойности се използват за изчисляване, тогава дългата променлива тип трябва да се използва за задържане стойностите.
