ஜாவாவில் எண் ஆபரேட்டர்கள்

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

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;

       System.out.println(x+y);
       System.out.println(x-y);
       System.out.println(x*y);
       System.out.println(x/y);
   }
}

கன்சோல் வெளியீடு: 1032 966 32967 30 நீங்கள் ஏற்கனவே இதைப் பயன்படுத்தியுள்ளீர்கள். இந்த குழுவில், நீங்கள் மீதமுள்ள அல்லது மாடுலோ ( ) ஆபரேட்டரில் சேர்க்கலாம் %.

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 33%2;
       System.out.println(y);
   }
}

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

• சமம் ( ==)
• >( ) விட பெரியது
• <( ) விட குறைவாக
• >=( ) ஐ விட அதிகமாகவோ அல்லது சமமாகவோ
• <=( ) ஐ விட குறைவாக அல்லது சமமாக
• சமமாக இல்லை ( !=)

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

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 999;
       System.out.println(x=y);// We expect false to be displayed
   }
}

கன்சோல் வெளியீடு: 999 அச்சச்சோ! இது வெளிப்படையாக நாம் எதிர்பார்த்த முடிவு அல்ல. இது முற்றிலும் மாறுபட்ட தரவு வகை: நாங்கள் ஒரு பூலியனைப் பார்ப்போம் என்று எதிர்பார்த்தோம் , ஆனால் எங்களுக்கு ஒரு எண் கிடைத்தது. எல்லாமே ஒப்பீட்டிற்குப் பதிலாக அடைப்புக்குறிக்குள் அசைன்மென்ட் ஆபரேட்டரைப் பயன்படுத்தியதால் . (999) இன் மதிப்பு மாறிக்கு ஒதுக்கப்பட்டது , பின்னர் அதன் மதிப்பைக் காட்டுவோம் . அதைச் செய்வதற்கான சரியான வழி இங்கே: x=yyxx

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 999;
       System.out.println(x==y);
   }
}

கன்சோல் வெளியீடு: தவறு இப்போது இரண்டு எண்களையும் சரியாக ஒப்பிட்டுப் பார்த்தோம்! :) ஒதுக்கீட்டு ஆபரேட்டரின் மற்றொரு அம்சம் ( =): இது ஒன்றாக "சங்கிலி" செய்யப்படலாம்:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;
       int z = 256;

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

கன்சோல் வெளியீடு: 256 ஒதுக்கீடு வலமிருந்து இடமாக இருப்பதை நினைவில் கொள்ளுங்கள் . இந்த வெளிப்பாடு ( x = y = z) படிகளில் செயல்படுத்தப்படும்:

• y = z, அது,y = 256
• x = y, அது,x = 256

யூனரி ஆபரேட்டர்கள்.

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

• யூனரி மைனஸ். இது எண்ணின் அடையாளத்தை புரட்டுகிறது.

public class Main {

   public static void main(String[] args) {

       int x = 999;

       // Change the sign for the first time
       x = -x;
       System.out.println(x);

       // Change the sign for the second time
       x= -x;
       System.out.println(x);
   }
}

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

• அதிகரிப்பு (++) மற்றும் குறைப்பு (--)

ஆபரேட்டர் ++ஒரு எண்ணை அதிகரிக்கிறார், மேலும் --ஆபரேட்டர் ஒரு எண்ணை அதே அளவு குறைக்கிறார்.

public class Main {

   public static void main(String[] args) {

       int x = 999;
       x++;
       System.out.println(x);

       x--;
       System.out.println(x);
   }
}

கன்சோல் வெளியீடு: 1000 999 நீங்கள் C++ மொழியைப் பற்றி கேள்விப்பட்டிருந்தால், இந்தக் குறியீடு உங்களுக்கு நன்கு தெரிந்திருக்கும். "C++ என்பது C மொழியின் நீட்டிப்பு" என்ற கருத்தை வெளிப்படுத்த அதன் படைப்பாளிகள் இந்த சுவாரஸ்யமான பெயரைப் பயன்படுத்தினர், Notepad இன் பிரபலமான மேம்படுத்தப்பட்ட பதிப்பு Notepad++ என்று அழைக்கப்படுகிறது, இங்கே ஒரு முக்கியமான விஷயம். இரண்டு வகையான அதிகரிப்பு மற்றும் குறைப்பு ஆபரேட்டர்கள் உள்ளன: போஸ்ட்ஃபிக்ஸ் மற்றும் முன்னொட்டு . x++- postfix ++x- முன்னொட்டு எண்ணுக்கு முன் அல்லது பின் கூட்டல்/குறைப்புகளை வைப்பதற்கு இடையே உள்ள அடிப்படை வேறுபாடு என்ன? பின்வரும் எடுத்துக்காட்டில் பார்ப்போம்:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = x++;
       System.out.println(y);
   }
}

கன்சோல் வெளியீடு: 999 ஏதோ சரியில்லை! x1 ஆல் அதிகரிக்கவும், y என்ற மாறிக்கு புதிய மதிப்பை ஒதுக்கவும் விரும்பினோம் . வேறு வார்த்தைகளில் கூறுவதானால், y என்பது 1000 ஆக இருக்க வேண்டும். ஆனால் அதற்குப் பதிலாக வேறு ஏதோ ஒன்றைப் பெறுகிறோம்: 999. x அதிகரிக்கப்படவில்லை என்பது போலவும், இன்க்ரிமென்ட் ஆபரேட்டர் வேலை செய்யவில்லை என்றும் தெரிகிறது? ஆனால் அது வேலை செய்தது. உங்களை நம்பவைக்க, xஇறுதியில் காட்ட முயற்சிக்கவும் :)

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = x++;
       System.out.println(y);
       System.out.println(x);
   }
}

கன்சோல் வெளியீடு: 999 1000 உண்மையில், அதனால்தான் இந்த செயல்பாடு போஸ்ட்ஃபிக்ஸ் என்று அழைக்கப்படுகிறது: இது முக்கிய வெளிப்பாட்டிற்குப் பிறகு செய்யப்படுகிறது. இதன் பொருள், எங்கள் விஷயத்தில்: int y = x++; y = xமுதலில் செய்யப்படுகிறது (மற்றும் மாறி yமதிப்புக்கு துவக்கப்படும் x), பின்னர் மட்டுமே செயல்படுத்தப்படும், x++இது நாம் விரும்பும் நடத்தை இல்லையென்றால் என்ன செய்வது? பின் நாம் முன்னொட்டு குறிப்பைப் பயன்படுத்த வேண்டும் :

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = ++x;
       System.out.println(y);
   }
}

இந்த வழக்கில், ++xமுதலில் செயலாக்கப்படுகிறது மற்றும் பின்னர் மட்டுமே y = x; நிறைவேற்றப்பட்டது. ஒரு உண்மையான நிரலில் தவறுகள் ஏற்படுவதைத் தவிர்க்க, இந்த வித்தியாசத்தை நீங்கள் இப்போதே நினைவகத்தில் ஈடுபடுத்த வேண்டும், அதற்குப் பதிலாக முன்னொட்டைப் பயன்படுத்துவது எல்லாவற்றையும் தலைகீழாக மாற்றிவிடும் :)

கூட்டு இயக்கிகள்

கூடுதலாக, ஜாவாவில் கலவை ஆபரேட்டர்கள் என்று அழைக்கப்படுபவை உள்ளன. அவை இரண்டு ஆபரேட்டர்களை இணைக்கின்றன:

• பணி
• எண்கணித இயக்கிகள்

இவற்றில் அடங்கும்:

• +=
• -=
• *=
• /=
• %=

ஒரு உதாரணத்தைக் கருத்தில் கொள்வோம்:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;

       x += y;
       System.out.println(x);
   }
}

கன்சோல் வெளியீடு: 1032 x += y என்பது x = x + y. சுருக்கத்திற்காக இரண்டு குறியீடுகளும் தொடர்ச்சியாகப் பயன்படுத்தப்படுகின்றன. சேர்க்கைகள் -=, *=மற்றும் அதே வழியில் வேலை /=.%=

தருக்க ஆபரேட்டர்கள்

எண் ஆபரேட்டர்கள் தவிர, பூலியன் மதிப்புகளை உள்ளடக்கிய செயல்பாடுகளையும் ஜாவா கொண்டுள்ளது ( உண்மை மற்றும் தவறு ). இந்த செயல்பாடுகள் தருக்க ஆபரேட்டர்களைப் பயன்படுத்தி செய்யப்படுகின்றன

• !- தருக்க இல்லை . இது பூலியனின் மதிப்பை புரட்டுகிறது

public class Main {

   public static void main(String[] args) {

       boolean x = true;
       System.out.println(!x);
   }
}

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

• &&- தருக்க மற்றும் . இரண்டு செயல்களும் உண்மையாக இருந்தால் மட்டுமே அது உண்மையாக இருக்கும் .

public class Main {

   public static void main(String[] args) {

       System.out.println(100 > 10 && 100 > 200);
       System.out.println(100 > 50 && 100 >= 100);
   }
}

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

• ||- தருக்க அல்லது . குறைந்தபட்சம் ஒரு செயலியாவது உண்மையாக இருக்கும்போது அது உண்மையாக இருக்கும் .

இந்த ஆபரேட்டரைப் பயன்படுத்தும்போது, ​​எங்களின் முந்தைய உதாரணம் வேறுபட்ட முடிவைத் தருகிறது:

public class Main {

   public static void main(String[] args) {

       System.out.println(100 > 10 || 100 > 200);
   }
}

கன்சோல் வெளியீடு: உண்மை வெளிப்பாடு 100 > 200இன்னும் தவறானது, ஆனால் OR ஆபரேட்டருக்கு முதல் பகுதி ( ) உண்மையாக இருந்தால் போதுமானது 100 > 10.