ஜாவா பிட்வைஸ் ஆபரேட்டர்கள்

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

public class Main {

   public static void main(String[] args) {

       int x = 342;
       System.out.println(Integer.toBinaryString(x));
   }
}

கன்சோல் வெளியீடு: 101010110 1010 10110 (படிப்பதை எளிதாக்குவதற்காக இடத்தைச் சேர்த்துள்ளேன்) என்பது தசம அமைப்பில் உள்ள எண் 342 ஆகும். நாங்கள் உண்மையில் இந்த எண்ணை தனிப்பட்ட பிட்களாகப் பிரித்துள்ளோம்: பூஜ்ஜியங்கள் மற்றும் ஒன்று. பிட்களில் செய்யப்படும் செயல்பாடுகள் பிட்வைஸ் எனப்படும் .

• ~ - பிட்வைஸ் இல்லை.

இந்த ஆபரேட்டர் மிகவும் எளிமையானது: இது நம் எண்ணின் ஒவ்வொரு பிட்டையும் கடந்து, பிட்டைப் புரட்டுகிறது: பூஜ்ஜியங்கள் ஒன்று, மற்றும் ஒன்று பூஜ்ஜியங்களாக மாறும். அதை நமது எண் 342 க்கு பயன்படுத்தினால், என்ன நடக்கும் என்பது இங்கே: 101010110 என்பது 342 பைனரி எண்ணாகக் குறிப்பிடப்படுகிறது 010101001 என்பது வெளிப்பாட்டின் மதிப்பு ~342 இதை நடைமுறைக்குக் கொண்டுவர முயற்சிப்போம்:

public class Main {

   public static void main(String[] args) {

       int x = 342;
       System.out.println(~x);
   }
}

கன்சோல் வெளியீடு: 169 169 என்பது பழக்கமான, தசம அமைப்பில் எங்களின் முடிவு ( 010101001 ) :)

• & - பிட்வைஸ் மற்றும்

நீங்கள் பார்க்க முடியும் என, இது தருக்க மற்றும் ( && ) க்கு மிகவும் ஒத்ததாக இருக்கிறது. && ஆபரேட்டர் , நீங்கள் நினைவுபடுத்துவீர்கள், இரண்டு செயல்களும் உண்மையாக இருந்தால் மட்டுமே உண்மை எனத் திரும்பும். பிட்வைஸ் & இதே வழியில் செயல்படுகிறது: இது இரண்டு எண்களை பிட் பிட் ஒப்பிடுகிறது. ஒப்பீடு மூன்றாவது எண்ணை உருவாக்குகிறது. எடுத்துக்காட்டாக, 277 மற்றும் 432 என்ற எண்களை எடுத்துக் கொள்வோம்: 110110000 என்பது 277 என்பது பைனரி எண்ணாகக் குறிப்பிடப்படுகிறது 1000101011 என்பது 432 பைனரி எண்ணாகக் குறிப்பிடப்படுகிறது அடுத்து, ஆபரேட்டர் & மேல் எண்ணின் முதல் பிட்டை கீழ் எண்ணின் முதல் பிட்டுடன் ஒப்பிடுகிறார். இது ஒரு AND ஆபரேட்டர் என்பதால், இரண்டு பிட்களும் 1 ஆக இருந்தால் மட்டுமே முடிவு 1 ஆக இருக்கும். வேறு எந்த சந்தர்ப்பத்திலும், முடிவு 0. 100010101 && ஆபரேட்டர் முதலில், இரண்டு எண்களின் முதல் பிட்கள், பின்னர் இரண்டாவது பிட்கள், பின்னர் மூன்றாவது, மற்றும் பலவற்றை ஒப்பிடுகிறோம். நீங்கள் பார்க்க முடியும் என, இரண்டு நிகழ்வுகளில் 1 (முதல் மற்றும் ஐந்தாவது பிட்கள்) க்கு சமமான எண்களில் இரண்டும் தொடர்புடைய பிட்கள். மற்ற அனைத்து ஒப்பீடுகளும் 0 வி. எனவே இறுதியில் 10001000 என்ற எண்ணைப் பெற்றோம். தசம அமைப்பில், இது 272 என்ற எண்ணுக்கு ஒத்திருக்கிறது. சரிபார்ப்போம்:

public class Main {

   public static void main(String[] args) {
       System.out.println(277&432);
   }
}

கன்சோல் வெளியீடு: 272

• | - பிட்வைஸ் அல்லது.

இந்த ஆபரேட்டர் அதே வழியில் செயல்படுகிறது: இரண்டு எண்களை பிட் பை பிட் ஒப்பிடுதல். இப்போது மட்டும் பிட்களில் குறைந்தபட்சம் ஒன்று 1 என்றால், முடிவு 1. அதே எண்களைப் பார்ப்போம் (277 மற்றும் 432): 100010101 | 110110000 _______________ 110110101 - முடிவு | ஆபரேட்டர் இங்கே நாம் ஒரு வித்தியாசமான முடிவைப் பெறுகிறோம்: இரண்டு எண்களிலும் பூஜ்ஜியமாக இருந்த பிட்கள் மட்டுமே பூஜ்ஜியங்களாக இருக்கும். இதன் விளைவாக எண் 110110101 ஆகும். தசம அமைப்பில், இது 437 என்ற எண்ணுடன் ஒத்துப்போகிறது சரிபார்ப்போம்:

public class Main {

   public static void main(String[] args) {
       System.out.println(277|432);
   }
}

கன்சோல் வெளியீடு: 437 எல்லாவற்றையும் சரியாகக் கணக்கிட்டோம்! :)

• ^ - பிட்வைஸ் XOR (பிரத்தியேக அல்லது)

இந்த ஆபரேட்டரை நாங்கள் இன்னும் சந்திக்கவில்லை. ஆனால் இதில் சிக்கலான எதுவும் இல்லை. இது சாதாரண OR ஆபரேட்டரைப் போன்றது. ஒரு வித்தியாசம் உள்ளது: குறைந்தபட்சம் ஒரு செயலியாவது உண்மையாக இருந்தால் சாதாரண அல்லது உண்மை என்று திரும்பும். ஆனால் அது ஒன்றாக இருக்க வேண்டியதில்லை: இரண்டு செயல்களும் உண்மையாக இருந்தால், முடிவு உண்மையாக இருக்கும். ஆனால் பிரத்தியேகமான அல்லது உண்மையாகத் திருப்பியளிக்கும் செயல்களில் ஒன்று சரியாக இருந்தால் மட்டுமே. இரண்டு செயல்களும் உண்மையாக இருந்தால், சாதாரண OR உண்மை ("குறைந்தபட்சம் ஒரு உண்மை") என்பதைத் தரும், ஆனால் XOR தவறானதாகத் திரும்பும். அதனால்தான் இது பிரத்தியேக OR என்று அழைக்கப்படுகிறது. முந்தைய பிட்வைஸ் ஆபரேட்டர்கள் எவ்வாறு செயல்படுகின்றன என்பதை அறிந்தால், நீங்கள் 277 ^ 432 ஐ எளிதாகக் கணக்கிடலாம். ஆனால் அதை மீண்டும் ஒரு முறை தோண்டி எடுப்போம் :) 100010101 ^ 110110000 _______________ 010100101 - முடிவு ^ஆபரேட்டர் இது எங்கள் முடிவு. இரண்டு எண்களிலும் ஒரே மாதிரியான பிட்கள் 0 ஐ உருவாக்குகின்றன (அதாவது "ஒரே ஒரு" சோதனை தோல்வியடைந்தது). ஆனால் 0-1 அல்லது 1-0 ஜோடியை உருவாக்கிய பிட்கள் ஒன்றாக மாறியது. எங்கள் முடிவு எண் 010100101. தசம அமைப்பில், இது 165 என்ற எண்ணுக்கு ஒத்திருக்கிறது. நமது கணக்கீடுகள் சரியாக உள்ளதா என்று பார்ப்போம்:

public class Main {

   public static void main(String[] args) {
       System.out.println(277^432);
   }
}

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

ஷிப்ட் விட்டு

இடதுபுறமாக பிட்களின் மாற்றத்தை << இதோ ஒரு எடுத்துக்காட்டு:

public class Main {

   public static void main(String[] args) {
       int x = 64;//value
       int y = 3;// Shift distance

       int z = (x << y);
       System.out.println(Integer.toBinaryString(x));
       System.out.println(Integer.toBinaryString(z));
   }
}

இந்த எடுத்துக்காட்டில், எண் x = 64 மதிப்பு என்று அழைக்கப்படுகிறது. மதிப்பின் பிட்கள் தான் நாம் மாற்றுவோம். பிட்களை இடதுபுறமாக மாற்றுவோம் ( << ஆபரேட்டரின் திசையில் இதை நீங்கள் யூகித்திருக்கலாம் ) பைனரி அமைப்பில், எண் 64 = 1000000 எண் y = 3 ஷிப்ட் தூரம் என்று அழைக்கப்படுகிறது. x எண்ணின் பிட்களை வலப்புறம்/இடது பக்கம் எத்தனை பிட்கள் மாற்ற விரும்புகிறீர்கள் என்பதை ஷிப்ட் தூரம் குறிக்கிறது. எங்கள் எடுத்துக்காட்டில், அவற்றை 3 பிட்களை இடதுபுறமாக மாற்றுவோம். ஷிப்ட் செயல்முறையை இன்னும் தெளிவாகக் காண, படத்தைப் பார்க்கவும். இந்த எடுத்துக்காட்டில், நாம் int s ஐப் பயன்படுத்துகிறோம். கணினியின் நினைவகத்தில் Ints 32 பிட்களை ஆக்கிரமித்துள்ளது. எங்கள் அசல் எண் 64 இப்படித்தான் தெரிகிறது: இப்போது நாங்கள் எங்கள் ஒவ்வொரு பிட்களையும் எடுத்து அவற்றை 3 இடங்களால் இடதுபுறமாக மாற்றுகிறோம்: எங்களுக்கு கிடைத்ததைப் பாருங்கள். நீங்கள் பார்க்க முடியும் என, எங்களின் அனைத்து பிட்களும் மாறிவிட்டன, மேலும் வரம்பின் விளிம்பில் இருந்து மேலும் 3 பூஜ்ஜியங்கள் சேர்க்கப்பட்டன. மூன்று, ஏனென்றால் நாம் 3 ஆல் மாற்றப்பட்டோம். நாம் 10 ஆல் மாற்றப்பட்டிருந்தால், 10 பூஜ்ஜியங்கள் சேர்ந்திருக்கும். எனவே, x << y என்ற வெளிப்பாடு " x எண்ணின் பிட்களை y இடங்களால் இடதுபுறமாக மாற்றுதல்" என்று பொருள்படும். எங்கள் வெளிப்பாட்டின் முடிவு 1000000000 என்ற எண் ஆகும், இது தசம அமைப்பில் 512 ஆகும். சரிபார்ப்போம்:

public class Main {

   public static void main(String[] args) {
       int x = 64;//value
       int y = 3;// Shift distance

       int z = (x << y);
       System.out.println(z);
   }
}

கன்சோல் வெளியீடு: 512 ஸ்பாட் ஆன்! கோட்பாட்டளவில், பிட்கள் முடிவில்லாமல் மாற்றப்படலாம், ஆனால் எங்கள் எண் ஒரு முழு எண்ணாக இருப்பதால் , எங்களிடம் 32 பைனரி இலக்கங்கள் மட்டுமே உள்ளன. இவற்றில், 7 ஏற்கனவே 64 (1000000) ஆக்கிரமித்துள்ளது. எனவே, நாம் 27 இடங்களை இடதுபுறமாக மாற்றினால், எங்களின் ஒரே ஒரு தரவு வகையின் வரம்பைத் தாண்டி தொலைந்துவிடும். பூஜ்ஜியங்கள் மட்டுமே இருக்கும்!

public class Main {

   public static void main(String[] args) {
       int x = 64;//value
       int y = 26;// Shift distance

       int z = (x << y);
       System.out.println(z);
   }
}

கன்சோல் வெளியீடு: 0 எதிர்பார்த்தபடி, கிடைக்கக்கூடிய 32 பிட்களுக்கு அப்பால் நகர்ந்து மறைந்துவிட்டது. பூஜ்ஜியங்களை மட்டுமே கொண்ட 32-பிட் எண்ணுடன் முடித்தோம். இயற்கையாகவே, இது தசம அமைப்பில் 0 க்கு ஒத்திருக்கிறது. இடப்பக்கம் மாற்றங்களை நினைவில் வைத்துக் கொள்வதற்கான எளிய விதி இங்கே உள்ளது: இடதுபுறம் உள்ள ஒவ்வொரு மாற்றத்திற்கும், எண் 2 ஆல் பெருக்கப்படுகிறது. பிட்கள் 111111111 << 3 பிட்களின் படங்கள் இல்லாமல் பின்வரும் வெளிப்பாட்டைக் கணக்கிட முயற்சிப்போம். 1111111111 என்ற எண்ணை 2 ஆல் பெருக்க வேண்டும் . இதன் விளைவாக, நமக்கு 888888888 கிடைக்கிறது. சில குறியீட்டை எழுதி சரிபார்ப்போம்:

public class Main {

   public static void main(String[] args) {
       System.out.println(111111111 << 3);
   }
}

கன்சோல் வெளியீடு: 888888888

வலதுபுறமாக மாறவும்

இந்த செயல்பாடு >> ஆல் குறிக்கப்படுகிறது . இது அதையே செய்கிறது, ஆனால் வேறு திசையில்! :) நாங்கள் சக்கரத்தை மீண்டும் கண்டுபிடிக்க மாட்டோம். அதே int 64 உடன் முயற்சிப்போம் .

public class Main {

   public static void main(String[] args) {
       int x = 64;//value
       int y = 2;// Shift distance

       int z = (x >> y);
       System.out.println(z);
   }
}

2 ஆல் வலதுபுறமாக மாறுவதன் விளைவாக, நமது எண்ணில் உள்ள இரண்டு தீவிர பூஜ்ஜியங்கள் வரம்பிற்கு வெளியே நகர்ந்து தொலைந்துவிடும். நாம் 10000 ஐப் பெறுகிறோம், இது தசம அமைப்பு கன்சோல் வெளியீட்டில் உள்ள எண் 16 க்கு ஒத்திருக்கிறது: 16 வலதுபுறம் மாற்றங்களை நினைவில் கொள்வதற்கான எளிய விதி இங்கே உள்ளது: வலதுபுறத்தில் உள்ள ஒவ்வொரு மாற்றமும் இரண்டால் வகுக்கப்படுகிறது, மீதமுள்ளவற்றை நிராகரிக்கிறது. எடுத்துக்காட்டாக, 35 >> 2 என்பது, நாம் 35 ஐ 2 ஆல் இருமுறை வகுக்க வேண்டும், மீதமுள்ள 35/2 = 17 (மீதத்தை நிராகரிக்கவும்) 17/2 = 8 (மீதியை நிராகரிக்கவும்) இறுதியில், 35 >> 2 வேண்டும் 8 க்கு சமமாக இருக்கும். சரிபார்ப்போம்:

public class Main {

   public static void main(String[] args) {
       System.out.println(35 >> 2);
   }
}

கன்சோல் வெளியீடு: 8

ஜாவாவில் ஆபரேட்டர் முன்னுரிமை

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

ஆபரேட்டர் முன்னுரிமை

அனைத்து செயல்பாடுகளும் இடமிருந்து வலமாக செய்யப்படுகின்றன, அவற்றின் முன்னுரிமையை கணக்கில் எடுத்துக்கொள்கின்றன. உதாரணமாக, நாம் எழுதினால்

int x  = 6 - 4/2;

பின்னர் பிரிவு செயல்பாடு ( 4/2 ) முதலில் செய்யப்படும். இது இரண்டாவதாக வந்தாலும், அதற்கு அதிக முன்னுரிமை உண்டு. அடைப்புக்குறிகள் மற்றும் அடைப்புக்குறிகள் அதிகபட்ச முன்னுரிமையைக் குறிக்கின்றன. பள்ளிக்கூடத்தில் இருந்து உங்களுக்கு நினைவிருக்கலாம். உதாரணமாக, நீங்கள் அவற்றை வெளிப்பாட்டில் சேர்த்தால்

int x  = (6 - 4)/2;

பின்னர் கழித்தல் முதலில் செய்யப்படுகிறது, ஏனெனில் அது அடைப்புக்குறிக்குள் இணைக்கப்பட்டுள்ளது. தருக்க && ஆபரேட்டரின் முன்னுரிமை குறைவாக உள்ளது (அட்டவணையைப் பார்க்கவும்), எனவே இது வழக்கமாக கடைசியாக இருக்கும். உதாரணத்திற்கு:

boolean x = 6 - 4/2 > 3 && 12*12 <= 119;

இந்த வெளிப்பாடு பின்வருமாறு செயல்படுத்தப்படும்:

• 4/2 = 2

boolean x = 6 - 2 > 3 && 12*12 <= 119;

• 12*12 = 144

boolean x = 6 - 2 > 3 && 144 <= 119;

• 6-2 = 4

boolean x = 4 > 3 && 144 <= 119;

அடுத்து, ஒப்பீட்டு ஆபரேட்டர்கள் செயல்படுத்தப்படுகின்றன:

• 4 > 3 = உண்மை

boolean x = true && 144 <= 119;

• 144 <= 119 = பொய்

boolean x = true && false;

இறுதியாக, AND ஆபரேட்டர் ( && ) கடைசியாக செயல்படுத்தப்படும்.

boolean x = true && false;
boolean x = false;

எடுத்துக்காட்டாக, கூட்டல்( + ) ஆபரேட்டருக்கு != (சமமாக இல்லை) ஒப்பீட்டு ஆபரேட்டரை விட அதிக முன்னுரிமை உள்ளது ; எனவே, வெளிப்பாட்டில்

boolean x = 7 != 6+1;

6+1 செயல்பாடு முதலில் செய்யப்படும், பின்னர் 7 != 7 சரிபார்ப்பு (இது தவறானது என மதிப்பிடுகிறது), இறுதியாக x (பொதுவாக அனைத்து ஆபரேட்டர்களின் மிகக்குறைந்த முன்னுரிமையை ஒதுக்குதல் ) மாறிக்கு முடிவு (தவறு) ஒதுக்கப்படும்; பார்க்கவும் மேசை). அச்சச்சோ! இது ஒரு பெரிய பாடம், ஆனால் நீங்கள் அதை செய்தீர்கள்! இந்த அல்லது முந்தைய பாடங்களில் சிலவற்றை நீங்கள் முழுமையாக புரிந்து கொள்ளவில்லை என்றால், கவலைப்பட வேண்டாம். எதிர்காலத்தில் இந்த தலைப்புகளில் ஒன்றுக்கு மேற்பட்ட முறை தொடுவோம். தருக்க மற்றும் எண்ணியல் செயல்பாடுகள் பற்றிய இரண்டு CodeGym பாடங்கள். விரைவில் இவற்றைப் பெற மாட்டோம், ஆனால் நீங்கள் இப்போது அவற்றைப் படிப்பதில் எந்தத் தீங்கும் இல்லை.