ஜாவாவில் இரண்டு எண்களைச் சேர்ப்பது எப்படி?

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

இந்த கட்டுரையில் பின்வரும் சுட்டிகள் விவரிக்கப்படும்,

• முறை 1
• முறை 2
• மீண்டும் மீண்டும் யூனரி ஆபரேட்டர்
• ஆரம்ப சுழற்சி அட்டவணை
• ஜாவாவில் பிட்வைஸ் மற்றும் பிட்ஷிஃப்ட் ஆபரேட்டர்
• மறுநிகழ்வு

எனவே பின்னர் தொடங்குவோம்,

ஜாவாவில் இரண்டு எண்களைச் சேர்த்தல்

முறை 1

திரையில் “இரண்டு எண்களைச் சேர்ப்பது” அச்சிட ஜாவாவில் ஒரு நிரலை உருவாக்குவதன் மூலம் நேரடியாக புரிந்துகொள்வோம்.

வகுப்பு AddTwoNumbers {பொது நிலையான வெற்றிட மெயின் (சரம் [] args) {System.out.println (“10 + 20 என்ற இரண்டு எண்களைச் சேர்ப்பது” + (10 + 20%)}}

வெளியீடு

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

பொது வகுப்பு முதன்மை {பொது நிலையான வெற்றிட மெயின் (சரம் [] ஆர்க்ஸ்) {System.out.println ('இரண்டு எண்களைச் சேர்த்தல்' + args [0] + '+' + args [1] + 'is' + (args [0 ] + args [1]))}}

10 மற்றும் 20 என்ற அதே எண்ணைக் கடக்கும்போது இதற்கான வெளியீடு கன்சோலில் காட்டப்படும்.

ஈ, எங்களுக்கு இங்கு கிடைத்த முடிவு விரும்பவில்லை 30. சரம் [] ஆர்குகளை நினைவில் கொள்ளுங்கள், நீங்கள் கன்சோலிலிருந்து எடுக்கும் ஒவ்வொரு உள்ளீடும் சரத்தில் குறிப்பிடப்படுகிறது. எனவே இங்கே நாம் கூடுதலாகக் கணக்கிட அந்த சரங்களை முழு எண்ணாக மாற்ற வேண்டும்.

பொது வகுப்பு முதன்மை {பொது நிலையான வெற்றிட மெயின் (சரம் [] ஆர்க்ஸ்) {//System.out.println( 'இரண்டு எண்களின் சேர்க்கை' + args [0] + '+' + args [1] + 'is' + (args [0] + args [1])) System.out.println ('இரண்டு எண்களைச் சேர்த்தல்' + args [0] + '+' + args [1] + 'என்பது' + (Integer.parseInt (args [0] ) + Integer.parseInt (args [1])))}}

வெளியீடு

இப்போது விரும்பிய வெளியீடு நமக்கு வேண்டும். இது 10 மற்றும் 20 இன் சேர்த்தல் 30 ஆகும், அதை நாம் சரம் முதல் முழு எண் வரை பாகுபடுத்தினோம்.

ஜாவாவில் இரண்டு எண்களைச் சேர்ப்பது குறித்த இந்த கட்டுரையில் அடுத்தது

முறை 2

1. கழித்தல் ஆபரேட்டரைப் பயன்படுத்துதல்: எதிர்மறை மதிப்பை மறுக்கும், இதனால் கூடுதலாக வரும் இரண்டு எண்களைச் சேர்க்க நாம் கழிப்பதைப் பயன்படுத்தலாம்.

பொது வகுப்பு AddTwoNumbers {public static int add (int a, int b) {return a - (-b)} public static void main (string [] args) {System.out.println (சேர் (10, 20)) கணினி. out.println (சேர் (-10, 20%)}}

அவுபுட்

30

10

ஜாவாவில் இரண்டு எண்களைச் சேர்ப்பது குறித்த இந்த கட்டுரையில் அடுத்தது

மீண்டும் மீண்டும் யூனரி ஆபரேட்டர்

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

பொது வகுப்பு HelloWorld {public static void main (string [] args) {System.out.println ('add' + add (10, 20%) System.out.println ('add' + add (-10, 20%) } பொது நிலையான எண்ணைச் சேர்க்கவும் (int a, int b) {//System.out.println ('--->' + a + ':' + b) போது (a> 0) {//System.out.println ('a> 0 --->' + a + ':' + b) b ++ a--} போது (a<0) { //System.out.println('while a ' + a + ' : ' + b) b-- a++ } //System.out.println('return b--->'+ a +': '+ b) திரும்ப b}}

அவுபுட்

$ javac HelloWorld.java $ java -Xmx128M -Xms16M HelloWorld add 30 add 10

ஜாவாவில் இரண்டு எண்களைச் சேர்ப்பது குறித்த இந்த கட்டுரையில் அடுத்தது

ஜாவாவில் பிட்வைஸ் மற்றும் பிட்ஷிஃப்ட் ஆபரேட்டர்

XOR பிட்வைஸ் ஆபரேட்டரைப் பயன்படுத்துவதன் மூலம் இரண்டு முழு எண்களைச் சேர்ப்பதையும் நாம் செய்யலாம் மற்றும் கேரியை AND ஆபரேட்டர் பெறலாம். கூட்டுத்தொகையைச் சேர்க்க நாம் கையொப்பமிடப்பட்ட இடது ஷிப்ட் ஆபரேட்டரைப் பயன்படுத்த வேண்டும். இது எவ்வாறு நிகழ்கிறது? முதலில் ஒரு உதாரணத்தைப் பார்ப்போம்.

பொது வகுப்பு HelloWorld {public static void main (string [] args) {System.out.println ('+ ve ஐப் பயன்படுத்துதல்' + addUsingBits (10, 20%) System.out.println ('-ve ஐப் பயன்படுத்தி கூட்டல்' + addUsingBits ( -10, 20))} பொது நிலையான int addUsingBits (int a, int b) {போது (b! = 0) {int carry = (a & b) a = a ^ bb = carry<< 1 } return a } }

வெளியீடு

$ javac HelloWorld.java

$ java -Xmx128M -Xms16M HelloWorld

+ Ve 30 ஐப் பயன்படுத்தி சேர்த்தல்

-V 10 ஐப் பயன்படுத்தி சேர்த்தல்

எப்போதும் நினைவில் கொள்ளுங்கள், இரண்டு பிட்களைச் சேர்ப்பதை மதிப்பீடு செய்ய XOR செயல்பாடு பயன்படுத்தப்படுகிறது. இரண்டு பிட்களின் கேரியை மதிப்பிடுவதற்கு செயல்பாடு பயன்படுத்தப்படுகிறது. இதைப் பிரிப்போம்? உள்ளீட்டு மதிப்புகள் மூலம் செல்லும்போது முதல் நிலைக்கு ஒரு = 10 மற்றும் பி = 20 ஐ எடுத்துக் கொள்வோம்.

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

ஜாவாவில் இரண்டு எண்களைச் சேர்ப்பது குறித்த இந்த கட்டுரையில் அடுத்தது

ஆரம்ப சுழற்சி அட்டவணை

சுழற்சி 1.

ஜாவாவில் அடாப்டர் வகுப்பு எடுத்துக்காட்டாக

மேலும் & ஹெலிப் லூப் ப்ரீவிட்டிக்கு பி = 0 ஆக மாறும் வரை எல்லா முடிவுகளும் இங்கே காட்டப்படாது. எனவே கீழே உள்ள அட்டவணை இந்த செயல்பாட்டின் கடைசி சுழற்சியைக் குறிக்கிறது.

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

ஜாவாவில் இரண்டு எண்களைச் சேர்ப்பது குறித்த இந்த கட்டுரையில் அடுத்தது

மறுநிகழ்வு

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

பொது நிலையான எண்ணான addUsingRecursion (int a, int b) {if (b == 0) ஒரு முழு எண்ணைத் திருப்பி = a ^ b int carry = (a & b)<< 1 return add(sum, carry) }

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

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

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

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