ஜாவாவில் நீண்ட எண்ணாக மாற்றுவது எப்படி

இந்த கட்டுரையில், ஜாவாவில் நீண்ட எண்ணாக மாற்றுவது மற்றும் சில குறியீடு எடுத்துக்காட்டுகளை எழுதுவது எப்படி என்பதை விளக்கப் போகிறோம் . நீண்ட என்பது int ஐ விட பெரிய தரவு வகை என்பதால் , இங்கே நாம் அத்தகைய மாற்றத்திற்கு வகை வார்ப்புகளைப் பயன்படுத்த வேண்டும். ஜாவாவில் லாங் மற்றும் இன்ட் இரண்டும் பழமையான தரவு வகைகள் என்பதை நீங்கள் ஏற்கனவே அறிந்திருக்கலாம் . அதாவது அவை வர்க்கப் பொருள்கள் அல்ல. அனைத்து பொருள்களும் அணிவரிசைகளும் Heap Space இல் சேமிக்கப்படும் அதேவேளையில் int மற்றும் long போன்ற பழமையான வகைகள் Stack நினைவகத்தில் சேமிக்கப்படும். நீளமும் முழு எண்ணும் ஓரளவு ஒத்தவை. முழு எண் என்பது முழு எண், அது நேர்மறை, எதிர்மறை அல்லது பூஜ்ஜியமாக இருக்கலாம். இரண்டும் நீளமானதுமற்றும் int என்பது முழு எண் வகைகளாகும், எனவே அவை ஒரு வகையில் இணக்கமாக இருக்கும். பிரச்சனை என்னவென்றால், நீண்ட வகை -263 முதல் 263 – 1 வரை, அல்லது -9223372036854775808 முதல் 9223372036854775807 வரை இருக்கும். அதாவது, ஜாவா நிரல் நீண்ட வகைக்கு 64 பிட்களை ஒதுக்குகிறது . அதே நேரத்தில், int வகை 32 பிட்களை ஆக்கிரமித்துள்ளது, அதில் நீங்கள் -231 முதல் 231 - 1 வரை எண்களை வைக்கலாம் அல்லது, -2147483648 முதல் 2147483647 வரையிலான எண்களை வைக்கலாம். இதன் பொருள், எந்த எண்ணான எண்ணையும் எளிதாகப் பொருத்த முடியும். நீண்ட வகை. ஜாவாவில், பழமையானவற்றுடன் பணிபுரியும் போது, ​​குறுகலான வகையிலிருந்து பரந்த வகைக்கு மாற்றுவது தானாகவே இருக்கும். மற்றொரு வழியில், இது அகலப்படுத்துதல் என்று அழைக்கப்படுகிறது.

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

இங்கே நாம் ஒரு நீண்ட மாறிக்கு ஒரு எண்ணை ஒதுக்குகிறோம் . எல்லாம் சீராக நடந்தது, ஒரு பெரிய வரம்பில், சிறியது அமைதியாக பொருந்துகிறது மற்றும் நினைவக இடத்தைத் தவிர எதையும் இழக்க மாட்டோம். மூலம், நாம் நீண்ட வகையின் மாறியை அறிவித்து அதன் மதிப்பை வரையறுக்கும்போது, ​​அதற்கு l என்ற எழுத்தை ஒதுக்குவது நல்லது , எண்ணுக்கு வெளியே உள்ள எண்களுடன் பணிபுரியும் போது இது கைக்கு வரும் .

long myVeryLong = 10000000000l;

ஜாவா நீண்ட முதல் முழு எண்ணாக மாறுகிறது

இப்போது இந்தக் கட்டுரையின் முக்கியப் பணிக்கு வருவோம் - ஜாவா லாங் டு இன்ட் கன்வெர்ஷன். பிரச்சனை என்னவென்றால், பெரியது எப்போதும் சிறியவற்றுடன் பொருந்தாது. எனவே இங்கே நாம் ஜாவாவில் தானாக “சிறியது” என்பதை “பெரியது” என்று வைக்க முடியாது. முந்தைய எடுத்துக்காட்டில் செயல்பட முயற்சித்தால், ஆனால் நேர்மாறாக:

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

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

ஜாவா கம்பைலர் இதை செய்ய அனுமதிக்காது மற்றும் பிழையை ஏற்படுத்தும். எனவே இந்த செயல்பாட்டிற்கு, நாம் டைப்காஸ்டிங் என்று அழைக்கப்படுவதைப் பயன்படுத்த வேண்டும். இந்த செயல்முறை குறுகலான வகை மாற்றம் என்று அழைக்கப்படுகிறது. ஒரு மாறியைக் குறைக்க, உங்கள் மதிப்பை எந்த வகைக்கு அனுப்ப விரும்புகிறீர்கள் என்பதை நீங்கள் வெளிப்படையாகக் குறிப்பிட வேண்டும். ஒரு "சிறிய" நீளத்தை முழு எண்ணாக ( அது பொருந்த வேண்டும்) மற்றும் இரண்டு "பெரிய" நீண்ட எண்களை முழு எண்ணாக வைக்க முயற்சிப்போம் .

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

நீண்ட மதிப்பை ஒரு முழு எண்ணாக மாற்ற வேண்டும் என்று கம்பைலருக்கு அறிவித்துள்ளோம் , மேலும் இந்த முடிவின் விளைவுகளுக்கு நாங்கள் பொறுப்பாவோம். தொகுப்பி, ஒரு குறுகிய வகையின் வெளிப்படையான குறிப்பைக் கண்டு, மாற்றத்தைச் செய்கிறது. இதன் விளைவாக, நாங்கள் வெளியீட்டைப் பெறுகிறோம்: சரி, 16000 கண்டிப்பாக நாம் பார்க்க வேண்டும் என்று எதிர்பார்த்தோம், ஆனால் -2147483648 இல் மைனஸ் ஏன்? இந்த 1410065408 என்றால் என்ன? உண்மை என்னவென்றால், அத்தகைய எண்கள் ஒரு நீண்ட மாறியில் சேமிக்கப்பட்டன , இது நாம் நினைவில் வைத்துள்ளபடி, 64 பிட்களை எடுக்கும். இந்த எண்களை 32 பிட்களை மட்டுமே சேமிக்கக்கூடிய ஒரு முழு எண்ணாக மாற்ற முயற்சிக்கிறோம் . ஒரு விதியாக, இந்த 32 கலங்களில் பூஜ்ஜியங்கள் மற்றும் நீண்ட எண்ணின் முதல் 32 பிட்களில் இருந்து ஒன்று இருக்கும் , மீதமுள்ளவை வெறுமனே நிராகரிக்கப்படும். எனவே, அசல் எண் 32 பிட்களுக்கு பொருந்தவில்லை என்றால், பொருந்தாத பிட்கள் வெறுமனே நிராகரிக்கப்படும். அதனால்தான் எங்களிடம் சரியான எண் 16000 மட்டுமே உள்ளது, ஏனெனில் இது 32 பிட்களுக்கு குறைவாகவே எடுக்கும்.

ஜாவா 8 நீளமாக முழு எண்ணாக மாறுகிறது

ஜாவா 8 இல், கணித வகுப்பில் ஒரு புதிய முறை உள்ளது, அது நீளத்தை முழு எண்ணாக மாற்றும் . அது இங்கே உள்ளது:

Math.toIntExact(value);

இந்த முறையின் சிறந்த விஷயம் என்னவென்றால், மாற்றப்பட்ட எண்ணின் நீளத்தை இது கட்டுப்படுத்துகிறது, மேலும் மதிப்பு ஒரு எண்ணுக்கு பொருந்தாத அளவுக்கு அதிகமாக இருந்தால் , அது விதிவிலக்கு அளிக்கும். எங்கள் எடுத்துக்காட்டில் இது எவ்வாறு செயல்படுகிறது என்பதைப் பார்ப்போம்:

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 ஐ எண்ணுக்குள் தள்ள முயற்சிக்கும் போது , ​​முறை விதிவிலக்கு அளித்தது. எனவே கிளாசிக் ஜாவா லாங் டு இன்ட் கன்வெர்ஷனைப் போல, நிராகரிக்கப்பட்ட பிட்களின் பிரச்சனை எங்களிடம் இல்லை .